My Favourite Podcasts in 2017

I’ve blogged about why software podcasts are awesome and why you should listen to them in the past. In this post, I’m giving an update on my favourite podcasts in 2017.

Software Engineering Daily

software engineering dailyThis podcast is still my goto podcast for all things software. The majority of episodes are worth a listen and many are essential listening.

The New Stack

the new stack There are a few New Stack podcast series. Makers, Analysts, & @Scale. Great podcasts for learning about new technologies, but also about the different and emerging players in the industry. There’s also some great coverage from some interesting conferences like KubeCon, etc.

Cloud Podcasts

the cloud castAWS TechChat
AWS podcastGoogle Cloud Platform Podcast

Are we moving into a hybrid cloud future? Who knows, but keeping up with the developments of the major public clouds is definitely a glimpse into the future. These podcasts are all really good and overlap with a lot of what is happening in the open source world anyway. Another good avenue to hear about those things too. Also, they’re a great place to learn about best practices, both for a specific cloud and for cloud architecture in general.

In terms of best practices and more in-depth coverage, AWS re-invent, the annual AWS cloud conference is released in podcast form each year. Here’s the podcast from 2016. You might want to pick and choose your episodes from this one as there are lots.

Software Engineering Radio

software engineering radioThis podcast has been bumped down my list due to the slower pace of new episodes, but they can still bust out a great episode from time to time. Some recent highlights are an episode with John Allspaw on system failures and another with Michael Feathers on legacy code.

Other Favourites

Manager Tools

Manager ToolsThis is my goto podcast for all things management. Excellent advice on how to approach or how to handle a variety of situations. I can’t believe this stuff is free! There’s also another pretty good podcast from the same guys called career tools. Some overlap in the content.


Exponent I love this podcast. Ben Thompson & James Allworth discuss recent developments and news in the tech industry. Excellent punditry on the subject, and highly entertaining. They are great at framing things and putting them in broader context. It’s really fascinating to hear about the strategies the tech giants are pursuing as they compete with each other.

Conversations with Tyler

conversations with tyler A fantastic podcast. It does cover many topics relevant to programmers like technological developments in other disciplines like biology, economics, sociology, etc. Frequently fascinating discussions. Basically like being a fly-on-the-wall for a conversation between two brilliant people, talking about something likely to be super interesting.

Reign in the madness: Intelligently using wikis for your dev team

TL;DR Wikis are awesome tools. When used poorly, they’re like black holes; documents disappear into the ether. When used intelligently, they can be powerful, self-organizing knowledge centers for your team.

On most large software projects, organization is key. Developers aren’t always the most organized people in the world (I’m no exception) and project managers tend to focus on the project schedule. This can leave something to be desired or tracking the team’s progress and keeping everyone on the same page in terms of technical decisions and understanding of the larger system architecture as the project progresses.

Most projects hit a speed bump or two along the way, and it isn’t uncommon to have people scrambling trying to remember what was agreed to and when or struggle to remember why or how a certain decision was made.

Continue reading “Reign in the madness: Intelligently using wikis for your dev team”

The Importance of Modernizing Legacy Code

The term legacy code conjures thoughts of dread in developers everywhere. It’s code that’s perceived (justly or unjustly) to be tightly-coupled, hard to understand, hard to change, and just plain out-dated. It’s an immovable object.

The reality is, legacy code is everywhere, and it isn’t going anywhere. So why not make it better, and make our lives working with it everyday easier?

Continue reading “The Importance of Modernizing Legacy Code”

Truly rapid development of admin apps with json-editor

At work we have a lot of configurable settings in our application. Like a lot. For a long time, nobody tackled the task of properly exposing the management of these settings in a UI because they thought it would be way too much work. The settings have a flat unified structure in the back-end, making them awkward to manage logically as a set of related settings. Building support for a large set of arbitrary data types, different editors for each, custom validation, etc. seemed like a daunting task.

In this blog post, I’m going to show how you can use the json-editor library to build these kinds of complex back-office admin apps really quickly and easily.

Continue reading “Truly rapid development of admin apps with json-editor”

Hello Idris

I heard a great podcast interview recently with Edwin Brady. He was discussing his upcoming book Type-driven development With Idris. After listening to the podcast, I immediately picked up a copy of his book. Having now completed the book (well it’s a MEAP, so what’s finished so far), I’m finding Idris the language really intriguing.

I’ve always had a preference toward statically-typed languages. I just like the ability to specify type constraints and have some level of confidence of correctness in my programs before I run them.

Continue reading “Hello Idris”

From plumatic’s schema to clojure.spec

In a previous blog post, I showed an example of using plumatic’s schema with test.check and test.chuck. With the introduction of Clojure’s new spec library, I thought it would be interesting to revisit that post and port it from schema to spec. The code from this post is available on github.

Overall, the port was relatively straight-forward, though spec took some getting used to. spec provides similar facilities for what I was using in schema. It integrated with both test.check and test.chuck with no significant modifications!

Continue reading “From plumatic’s schema to clojure.spec”

Emacs Keyboard Setup – OSX

Before you get going with Emacs on a Mac, there are a number of keyboard settings that you generally want to tweak to get the most fluid and comfortable experience. This post outlines the keyboard settings changes I’ve made that I find essential.

Note: this is targeted towards OSX users. Not all of this will apply to other systems.

Continue reading “Emacs Keyboard Setup – OSX”

Why I’m learning Emacs

Emacs is a classic piece of software that has stood the test of time. It has been around for decades and will probably be around for decades to come, so though it has a bit of a learning curve, it’s well worth the effort to learn.

Although my original motivation for learning Emacs was in pursuit of the ultimate clojure IDE experience, I’ve quickly realized it is extremely valuable as a general-purpose editor. My background has always been as an IDE guy (eclipse, IntelliJ IDEA, etc.), aside from knowing just enough vi to get around on the command-line.

Here’s some of the reasons I chose to invest in learning Emacs whole hog:

Continue reading “Why I’m learning Emacs”

Stackoverflow: Road to 5K

I recently reached 5K reputation on stackoverflow. It’s nothing mind blowing reputation-wise for sure, but it feels like a nice milestone that took some time and effort to reach. Thought I’d write a quick post summarizing my experiences on the site and share some tips & tricks I’ve found helpful along the way.

Continue reading “Stackoverflow: Road to 5K”

Making Sense of Stream Processing – A Must Read

Making Sense of Stream Processing Stumbled on this book this week, and devoured it in an afternoon.

Written by Martin Kleppmann, a distributed systems researcher and former engineer at LinkedIn (where Kafka was born), this book explores the ideas of stream processing and outlines how they can apply broadly to application architectures. It’s a small book in a report format, synthesized from a series of blog posts (linked on Martin’s website).

Continue reading “Making Sense of Stream Processing – A Must Read”