Image for post
Image for post

Clojure is a dynamic, functional programming language that is a joy to write. I’ve been writing it professionally for the last year-and-a-half and wanted to share something I wish existed when I first got started.

This guide is not a primer on Clojure itself. I will not be going over the basics of the language, there are plenty of great guides out there that are a web search away.

This guide, therefore, is aimed at:

  • Programmers coming from a different language who have decided to try Clojure;
  • Programmers that are writing Clojure for the first time professionally.

The motivation might be a quick way to get a reliable environment up and running, freeing up more time to focus on learning the language itself. …


Image for post
Image for post
Monzo Plus and Open Banking (from Monzo Press)

My use-case of Monzo is a daily spending card to ring fence “fun money”. Its budgeting tools are good enough for simple uses like mine, and the design is aesthetically pleasing.

I signed up to its recent offering — Monzo Plus — because I thought I would make use of the virtual cards, the ability to view my other accounts in Monzo, and the custom categories.

That, mostly, didn’t turn out to be the case.

The virtual cards’ design and integration into the app was quite clunky, and there was no way to easily pull up the card numbers. …


A sample component that fetches data from a JSONP endpoint…


Heroku mentions TAP support for running tests within their CI environment.

If the executed test scripts emit TAP-formatted output to STDOUT, individual passes and failures are counted and displayed in the test run’s UI.

Heroku indicates that the individual tests are displayed on the UI if the output is TAP compliant.

They don’t mention what this UI looks like, or how to know if the output is correctly being accepted as valid TAP output to get the enhanced UI.

I’ve taken some screen grabs of the before and after to save you some commits.

Without TAP

An error Continouous Integration build without TAP enabled.
An error Continouous Integration build without TAP enabled.
An error Continouous Integration build without TAP enabled.

With TAP


If you’re trying to add a dependency to a Swift library, the Package.swift file may have a dependencies section that resembles the line below.

dependencies: ["FeedKit", “SQLite”]

At the time of writing, the above line fails with the error below because the product and library names are different.

dependency 'SQLite' in target ‘…’ requires explicit declaration; reference the package in the target dependency with '.product(name: "SQLite", package: "SQLite.swift")'

The error message doesn’t tell you where to add the .product entry. After a bit of tinkering, I figured out how to get rid of this error message.

Replace the SQLite entry in the dependencies array with the .product declaration, e.g.

dependencies: ["FeedKit",
.product(name: "SQLite", package: "SQLite.swift")])

Image for post
Image for post
The M1 — Apple Silicon’s debut

It now costs £699 to start developing applications for Apple’s ecosystem — assuming you have an existing keyboard, mouse, and monitor.

The new Apple Silicon Mac Mini, MacBook Air, and MacBook Pro are excellent development computers for beginners and veterans alike. Early indications from the community seem to indicate that the community’s RAM worries were mostly premature; 8GB of RAM is enough to get some serious work done.

@davemark on Twitter summarises my opinion — “It’s fine to replace a 16GB Intel MacBook Pro with an 8GB M1” — although I would replace “fine” with “mostly fine”.

My personal computer is a 2018 13-inch Intel MacBook Pro with 4 Thunderbolt 3 ports, 16GB of RAM, and a 512 GB SSD. I love this computer because it handles tasks I throw at it gracefully. …


A view of the famous Hollywood sign from a distance.
A view of the famous Hollywood sign from a distance.
Creativity, competition, and cold, hard cash. Photo by Nico Amatullo on Unsplash

The United States of America — like it or not — is a huge influence on the world, particularly the Anglosphere. The nation and their people inspire many modern democracies. Ideas pioneered by the American entrepreneurial spirit have led to incredible progress.

America is a complicated country with a history filled with both despicable and heroic acts — its founding constitution stated that some human beings were worth three-fifths of others. The same country is also one of the most generous; a world leader in innovation, science, culture, and media.

I believe that Americans are good people on the whole. I’ve met, worked with, and competed against them. Americans have an infectious positivity and energy and a genuine belief that they can change the world. …


Performance should be a first-class citizen of every modern application.

There are plenty of reasons to justify putting performance at the forefront of your application, and this blog post isn’t about that.

This post is meant to discuss a high-level concept that allows you to gain massive speed improvements and, depending on the platform that you’re using, relatively minimal engineering effort.

Lazy loading is a design pattern commonly used in computer programming to defer initialization of an object until the point at which it is needed.

Wikipedia

In various areas of software engineering, lazy loading is an optimisation step that is particularly beneficial when data is expensive to render, or otherwise process, so you only load the data when the you, or the person using your software, needs it. …


A few months ago, I was introduced to a new way to write JavaScript. It’s name was Elm and its promise is to

Generate JavaScript with great performance and no runtime exceptions.

I was particularly intrigued by the latter part of the promise which prompted me to dip my toe in the water. Fast forward to today, I can safely say that Elm has fulfilled the promise it made.

Thinking back to my journey learning Elm, the most difficult part of getting comfortable with writing it was forcing myself to think the Elm way. I find that there is an Elm way of doing things, and trying to shoehorn concepts from other programming languages and frameworks into Elm will make things more difficult. …


Most users of POSIX based systems have most likely heard of or use the grep command regularly. For those who don’t know, grep is a method of searching an input file for a match of one or more patterns. It’s a very useful and powerful tool, especially when you pair it with some advanced regular expressions.

One of the things I didn’t know until yesterday, and thought would be interesting to share, is that you can also use grep on any Ruby class that includes the Enumerable module.

The output of ri Enumerable#grep is as follows:

= Enumerable#grep(from ruby core)
--------------------------------------------------------------------enum.grep(pattern) -> array
enum.grep(pattern) { |obj| block } ->…

About

Muyiwa Olu

I love computers, design, and people. Lead Software Engineer at eporta.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store