A Software Development Philosophy

A software development philosophy guides software developer careers. Some adhere to prevailing philosophies in books or code, and some invent a unique software worldview.

My philosophical influences come from Lean Domain-Driven Design (DDD), Test-Driven Development (TDD), The Agile Software Development Lifecycle, Developer Operations (DevOps), Observability, and many more.

Here’s my software development philosophy. I encourage you to write yours and join the conversation.

Invest Lightly

I avoid getting too wrapped up in details when using technology. Technology changes constantly; light and strategic investments provide more value.

I invest lightly with my keystrokes to maintain less code.

Invest Lightly

Stay Liquid

I avoid technical debt like COVID.

It’s frighteningly common to witness multi-million-dollar software projects scrapped and built for millions again.

A mountain of technical debt is no laughing matter; it will threaten the longevity of your business. I recommend paying your technical debt now. It is often cheaper to pay technical debt than rewrite software.

Stay Liquid

Everything Changes

When building code, I assume change is coming sooner than expected. I craft easy-to-adjust solutions that economically address new business requirements.

Everything Changes

Simple Security

Simple security is often an oxymoron, but there are solutions.

I create layers like bastion hosts to protect data rather than software configuration files and leave configuration files permissive while mostly unchanged to reduce confusion about access rules.

I require clients to identify themselves before calling my services. Legacy deprecation is hard enough without playing a game of whack-a-mole or running scream tests during migration activities.

I often remind myself that the only secure computer is a dead computer, and you better be sure it’s demolished, in the ocean, encased in cement, and buried.

Use the Right Tool

Languages are simply programming tools that exist to help us craft a solution. I contemplate the appropriate tool for a job and am acutely aware of The Law of Instrument.

I prefer learning many tools to support full-stack development proficiency. In software development, many people use one tool and master it. Specializing is lucrative; some developers will land a big payoff with this approach. However, I prefer to follow the 80-20 rule.

I’m pragmatic, yet I apply principles where applicable.

Be Pragmatic

The Mythical Man-Month

Many people look outside software development efforts and believe adding more people will speed up a project. I don’t blame them; it seems like the logical outcome; however, it’s never true on a short timeline.

I’m acutely aware of Brook’s Law. I know adding new people to a team will initially slow it down.

I simplify onboarding activities to lower the impact of adding new team members.

The Mythical Man Month

Cut With The Grain

I build solutions with an eye for opportunity. If hosting software is cheap with the cloud, do it, otherwise seek other less expensive solutions.

I reserve little space for dogma when choosing how to use resources.

I have little patience for wild west resource allocations. Build with the grain of opportunity

Measure Then Commit

I loved woodworking as a teenager.

Sacrificing quality at the altar of speed is common in the software industry.

Scratch that; it’s common everywhere.

Let’s do better.

I don’t mean we should build perfect solutions. I mean we should measure twice then commit.

I know everyone makes mistakes, and limiting human errors is critical. When building software, I focus on critical decisions, then fire tracer bullets to determine options. Once documented, I pass a proposal by my team to eliminate blind spots.

I love resolving high-impact problems. I live for this.

All The Logs In The Forest

If there’s a log, I’ll enable it. When I’m stuck debugging a problem, I never know what log entries might uncover, so I collect them all.

While information is essential, too much information drives me crazy. I appropriately classify logs with DEBUG, INFO, WARN, ERROR, and FATAL.

I use general-purpose logging solutions with aspect-oriented programming and move logging concerns away from the application layer.

All the logs in the forest

A Fresh Start

When I pick up a dusty software development tool, I approach my work as a newbie. I’ll Google for an appropriate modern tool and remind myself that my current tools may soon be worthless in our fast-paced industry.

I use principles to guide my efforts rather than my vast knowledge of a particular tool.

A fresh start

Solutions Looking For a Problem

I avoid creating solutions before solving a problem. I ask myself a simple question before building anything.

Does solving this problem add significant value?

If a solution to a problem isn’t providing significant value, I save the idea for later and focus on high-value solutions.

A solution looking for a problem

Reframe The Problem

I can’t eat a garden with one bite of an elephant.

If I am solving a complex problem I break it into manageable problems. I work methodically to create discrete solutions to simple problems.

I reframe difficult problems into a cheap educational solutions. Later, I will apply bronze, silver, or gold plated solutions depending on the impact of a failed solution.

Use Cases

It is vital to limit software use cases. A command-line utility’s use cases are easy to restrict while user interfaces are not. I limit use cases to avoid introducing a diverse collection of bugs.

Writing down a clear definition of use cases sets a clear contract between myself and users. When people use software outside of an intended use case, I use documentation to explore a new valid use case.

If I’m explicitly creating general-purpose software, I limit the use cases as much as possible to general-purpose features that developers can extend.

Use cases

Constraints

If it’s flapping around, I nail it down. I identify and document constraints before writing any code when tackling significant problems. Defining constraints limits choices and helps narrow a solution path.

I pay close attention to resource constraints and the price associated with those resources. Before implementing an architecture, I’ll review technical limitations and business rules to discover blockers or bottlenecks.

I look for opportunities to simplify business problems. I regularly validate previously defined constraints. If something changes in my favor, I’ll forge a new path to simplicity.

Software constraints

Versioning

When building software, my philosophy is to version most things. I abide by the rule; if it’s not broken, don’t fix it. I keep versions pinned so upgrades don’t happen without a developer’s knowledge and strike a balance between updating software for security reasons and letting sleeping dogs lie.

Major minor patch

Naming Things

When naming variables, I name them in ways that make them easy to rename. I call things exactly and avoid overloading or overusing the same variable name.

Two hard things in computer science

Tracer Bullets

I use tracer bullets to punch a hole in the walls between myself and a solution. I’ll use scattershot shotgun methods to prove use cases, theories, and the viability of a solution before investing time and money in building robust solutions. I’ll pick a requirement far from the final solution and meet it head-on.

Tracer bullets

There Are No Big Problems

As Henry Ford once said, there are just a lot of minor problems. Breaking down what looks like big problems into manageable problems makes software developers look like wizards. 🧙‍♂️

If I face a complex problem, I solve a minor problem and work from there.

No big problems

Driving Business Value

Everything I build has the end-user requirements placed front and center in my mind. Having a fancy contract with a lot of complexity won’t help sell more products than a simple one. If I can’t rationalize why a feature provides the highest value at a given time, I’ll raise my hand or change course on my own.

Single Responsibility

I keep software components isolated with a single responsibility and create single responsibility user interfaces to reduce complexity. I divide tools logically for users and other software developers, and I follow SOLID principles when creating object-oriented software solutions. I believe many software problems are caused by not following these principles.

Take Responsibility

Development Operations (DevOps) has transformed software development. Modern software development practices have greatly benefited from DevOps.

DevOps requires software development teams to take full responsibility for their creations. The DevOps maturity model increases the quality of products and increases the speed of delivery to the market.

I guide team members towards continuous improvement of build pipelines, testing methodologies, and other DevOps best practices.

Devops maturity model

There Is Always A Design

Designing a maintainable, malleable, and easy-to-understand system is of paramount importance. A design always exists. An unplanned design is terrible, but it is still a design. A poor design becomes a massive liability for a company and will slow a development team to a crawl.

I insist on a good design upfront. My primary goals include making a system sufficiently flexible, understandable, and affordable.

Ball of mud

Be Empathetic

I work diligently to understand what people need. I ask why five times to understand the real problems while keeping the big picture in mind. Empathy for people is a cornerstone of a robust software development philosophy.

Step Slowly

When solving complex problems, I step slowly through code. Slowly stepping through code helps isolate issues and solve them individually. I make manageable changes and then use a debugger to see the results.

I don’t cut corners when a path is clear. Quality is my more important than speed; speed emerges through quality.

Slow is smooth, smooth is fast. — Bob Martin

Step slowly

Automate Everything

I automate tasks religiously. I consider a different approach if it’s expensive to automate a solution.

Automate everything

Test For Life

I like focusing on solving problems. Without robust integration tests, unit tests, and other tests, we spend time creating problems for ourselves.

I write tests because manually running an app after every change.is tedious.

An automated test suite helps me sleep at night. Time spent coding without testing increases the time spent working on bugs, investigating production issues, and troubleshooting broken builds. I prevent future pain by testing; therefore, I test for life.

Test for life

Exceptions Are The Exception

I write code to avoid mistakes. Instead of throwing exceptions in the name of defensive programming, I change software designs to prevent thrown exceptions. After all, users depend on software to work and simplify their life; let’s keep it simple.

However, I bubble up exceptions with maximum traceability when required.

I implement messaging patterns, isolate control of resources, and identify other creative ways to avoid errors before throwing exceptions.

Exceptions are the exception

Decouple Everything

I refactor tightly coupled code to reduce complexity and prepare it for change. When tight couplings exist for no good reason, I decouple them.

I summarily dismiss software libraries that aren’t dependency injection-ready.

I ask myself five times why I’m coupling code before committing to tight coupling.

Decouple Everything

No Perfect Solutions

I know that picking the best solution, at the moment, with all the facts laid out, is the way to avoid analysis paralysis.

I don’t believe in the Nirvana fallacy and make the best decision possible at The Last Responsible Moment, yet at the same time, I take big architectural choices very seriously.

I know solutions can’t be fast, cheap, and good simultaneously, yet I strive for the right balance based on functional requirements.

Fast Cheap Good

Conway’s Law Is True

Conway’s Law states that the organization’s communication structure influences a system design.

Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization’s communication structure.
— Melvin E. Conway

If communication flows are complex so are systems.

I inspect organizational information flow to understand its procedures. If flow is inefficient, I propose a better solution.

Open Source is Life

I make use of open-source software whenever possible. I ensure the open-source software I use is well maintained and make safe bets on a project’s longevity. I’ll contribute to a project if it aligns with my development needs and enjoy the synergies that open-source software development models provide to businesses and developers.

Open Source

Can != Should

The software development world is full of many tools, methods, design patterns, and best practices. Frequently choice overload leads software developers to believe one tool can rule them all. 💍

Picking the wrong tools to solve your problem leads to technical debt and wasted time. Before tackling a problem, I will research what standard methods are used and choose the best tools for a specific situation.

Can != should

Confusion Is Painful

Software development is overly complicated as-is. I follow the principle of least astonishment when crafting solutions. If I’m taking an unconventional path, I prepare a steelman argument for doing so, keep the code simple, and document why I created a new approach.

I keep my variables consistent, methods clear, configuration files clean, and sound choices that eliminate inconsistencies within a given solution.

Inconsistency is an enemy of excellent software design.

Confusion is painful

Pair Programming FTW

I enjoy a productive pair programming session. I love sharing my hard-earned wisdom. Programming in the modern age is a self-induced chaos test meant to push my ability to understand EVERYTHING to the limit. When I help someone avoid the pain I’ve experienced, it brings me joy.

Another pair of eyes will make code easier to maintain and lower the total cost of ownership. Pair programming, when done right, will level up your team while turning it into a high-performing powerhouse.

Pair Programming FTW