Are you building for survival or excellence?

Source: https://www.youtube.com/attribution?v=oW2i6QpnmyY

In my experience, the approach to building a software artifact often falls into one of two types: building for survival, or building for success.

When building for survival, your only goal to get the product working for the specific usecase(s) that will save your skin. In contrast, when building for success, you are building to solve more than just the immediate problem; you are building to set up building blocks that is incidentally used to solve the immediate problem, but can also be adapted to solve a larger class of problems within the same context.

This post is not about when to choose what approach. Instead, it is about what each of the two approaches look like, and what purposes they serve. A subsequent post will talk about when I think each approach is appropriate.

Continue reading “Are you building for survival or excellence?” →

Object Composition for Service Migration

Object Composition is a very powerful and pervasive software design technique. Yet, paradoxically, it is an underutilized design pattern whose lack of usage is the root of many anti-patterns in software development. One that I continue to come across regularly has to do with not using composition to test and migrate a piece of software from one service to another.

Briefly, Object Composition is combining two or more objects to create more complex objects while keeping definitions of the constituent objects unchanged (unlike inheritance, which extends these definitions)

Continue reading “Object Composition for Service Migration” →

Scripts and their undo

TL;DR. Scripts are a great way to automate the mundane. But be sure you give yourself a way out — an undo — when running them.

Some time ago, I had to carry out a long sequence of manual changes in the deployment of my ‘cloud’ service, and so like a good software engineer, I automated large chunks of these changes with shell scripts. Here I learned the importance of building and ‘undo’ in all your shell scripts that mutate the state of world.

Read more

Merits of unit tests — part 5

Cross posted on LinkedIn.

This is the fifth, and final, post in my series of notes on unit tests. So far, we’ve talked about how unit tests help us in documenting our code, reliably refactor software, build better code, and even help debugging in prod. In this post, we’ll discuss how unit tests (more precisely, the act of writing unit tests) help us improve the usability of our code.

Continue reading “Merits of unit tests — part 5” →