Why You Should Start Learning, Now

(source: pixabay)

C++ is a language you should give serious consideration to learning in 2019 (or whenever you happen to come across this article). Rapid language modernization, better tooling, a growing and inclusive community, and a thriving job market are just some of the reasons C++ should be your next language to learn.

Wow, this guy drank too much Kool-Aid ™️️, I’m out.

Yeah, I get it. At least in the communities I’ve been a part of over the years, C++ has a consistently bad reputation.

The code is hideous.

An unmaintainable mess of paradigms.

Unmanaged code? No thank you, I like…


Is your tech-stack environmentally responsible?

(source: unsplash)

Climate change has been a part of the scientific communities’ discussions for some time now. More recently we’re starting to hear more from our local and national politicians and governments are taking action and encouraging their citizens to participate in reducing their footprint. We often focus on the more obvious tasks — recycling, producing less non-recyclable waste, driving less, maybe even volunteering in local tree-planting efforts, etc.

Similarly companies will sometimes announce that their business, or parts of their business, are carbon neutral. Often we see the use of electric vehicles in their fleet being the main article of their…


I want to go fast

I haven’t been programming for long, but I’ve gotten to the point where I’m a little bored working in Ruby, Python, Scala, PHP, C#, and JavaScript (to name a few). New languages feel like old languages, remixed. The concerns are more or less similar and the challenges feel the same. I need a new challenge.

(source: memeshappen.com)

But what does that mean? For me that has meant learning C++ and, well, building things that go really fast. This means learning a new domain and taking software craftsmanship to a new level. Keep reading and I’ll explain.

Wanting To Go Fast (in C++)

The ability to go fast has…


The basis for healthy community dynamics

(Photo by Toa Heftiba on Unsplash)

Reflecting back on my career so far, there are some bits of advice I wish I could tell my younger self (like to take a course on compilers 😄). One of them that I’ve been mulling over recently is more about social dynamics of how we write code within a team and how the code we write is as much of an interaction as a conversation. I’m sure this advice isn’t new but I have yet to find it wrapped up together like I hope to do here.

Don’t Break Standards

Often when joining a new company, team, or project; we bring a…


Slow down while going fast to go faster.

(source: pexels)

Rate-limits are an unfortunate part of life when developing/integrating against external APIs. Rate-limits vary in their implementation, but usually boil down to some sort of pre-defined limit on the number (and possibly type) of requests that can be made within a specific time-window.

Dealing with this when writing concurrent code, with multiple points of integration, can be difficult. Your first instinct may be to introduce retries; this, however, does not ensure fairness and results in data-races. To properly deal with, and adhere to, rate limits, the solution must have the properties:

  • serialization of requests (to ensure fairness)
  • track quota usage


Demystified with a jargon-free exploration.

(source: pexels.com)

Often we hear, learn, and even use terms or phrases that we don’t fully understand. I find this to be quite common within the software development community, whether is be RESTful Web APIs, Agile methodology, Machine Learning, or some other term. This isn’t necessarily a bad thing, but it’s important to understand when you truly know something and when you just know the name for it.

For me, Systems Programming is one such term. I’d like to try and explain, using simple language, what this means.

What is a System?

Before we can understand what Systems Programming entails, we first need to understand what…


A recipe for setting up Travis CI on your Go projects.

(source: ashleymcnamara/gophers)

TL;DR — Skip to bottom for full recipe.

Whether you’re an expert or beginner, building a toy program or production app, alone or with a team; Travis CI is an invaluable resource in your development toolkit. Providing automated, immediate feedback on code correctness, quality, and other user-defined behaviors.

This is very sales-pitch’y. I’m not sure I want to keep reading.

I’m not being paid by Travis-CI, I swear! Please keep reading! 🙏

If my awesome intro didn’t quite communicate everything, Travis CI is a platform to perform user-defined actions…


If you have written a CLI, maybe it should have also been a server.

As authors of CLIs and tooling, I’m sure the idea of integration has crossed your mind before. However, if your idea of integration includes the use of grep, then maybe it’s time to take a step back and consider other options.

Lately, I’ve been rewriting an internal company tool we have for managing database changes across various environments. The tool itself is rather straightforward to operate and is used in a multitude of environments. Developers use it when setting up and tearing down development environments or…


A common sight in Scala code is to see Future[T] used as the result of network-based operations (such as a web-request). However, when dealing with a network, failures can be common. It’s likely you’ll want to retry this operation, but should only be done so if coupled with exponential back-offs. This post will show you how we can easily compose futures to achieve this.

Mock API

For our examples to actually work (in a REPL anyways), let’s make up a mock API to use.

Note: The code-blocks are structured to be pasted into a REPL. Each example depends on functions and…


https://goo.gl/1oDBfh

Concurrency has many different abstractions: The classic processes and threads, the older but newly-new actor-based concurrency, CSP style concurrency (looking at you Go), and the quite popular future/promise. There are more, but one thing they all have in common is the goal to create a better way to achieve concurrent computation. This is great, if we understand what we’re abstracting.

When it comes to futures, there are a great number of articles online about how to get started using a particular implementation/framework for futures. However there is a much smaller number of articles that properly explain what a future is…

John Murray

Remote Developer. Writer. Kombucha Brewer. Owner of Corgis. https://medium.com/@john.m.murray786

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