Don't Outsmart Yourself


 

The great Richard Feynman had a saying.  "The first principle is that you must not fool yourself and you are the easiest person to fool."   

I believe there is a similar principle that can be applied to software engineering.  "Don't outsmart yourself."   

As a software engineer, it can be easy to:

  • Over-engineer a solution to a simple problem.
  • Strive for elegance over ease of understanding for others.
  • Use an obscure, or less popular approach to solve a problem.
  • Abstract away complexity pre-maturely.
  • Write a custom library when something that could have worked off the shelf would have sufficed but maybe wasn't a perfect fit.
It feels good to do these things.  It works parts of your brain that might be aching to do something interesting.   It can impress your peers.  

In time though, you will outsmart yourself. 

The smarter you are, the more prone you will be to outsmarting yourself.   The trick is to balance ego with prowess.  Yes, you could do it your super smart way, but it is just as effective half a dozen other ways.

Your elegant solution might not be as flexible as you thought, and new requirements may be harder to implement.

Your custom library might not keep up to date with industry trends, and soon those off the self solutions are miles ahead of where you are, and you don't have the time to add those new features.

That abstraction you created was hiding important features from the caller, and now others have made shortcuts and you have a leaky abstraction that serves no purpose.

That fancy new database you used has a custom query language, and a basic recursive query may have sufficed.  Now the new team that is maintaining your project must learn a new query language.

There is a time and place for elegant code, over-engineered solutions, and beautiful abstractions.  Your next work project is 95% likely to NOT be the time and place for them.   

Strive for understandable, well documented solutions.

Strive for maintainability when another team inherits your code.

Don't write code for your ego, write it for the next person.  You write it once, but it may get read hundreds of times by others.  Optimize for reads.  Don't outsmart yourself!

- Andy Glassman

Comments

Post a Comment

Popular posts from this blog

Phoenix LiveView: Async Assign Pattern

Image
I've been using LiveView for about two years now. It's a great framework that makes snappy and responsive pages. One anti-pattern I see fairly often is loading a lot of data in the initial page render. For the un-initiated, the mount/3 function is called twice.  Once for the initial 'dead' render, and again after the socket is connected.   Many times, for the sake of simple straight forward code, not much is done differently between these two renders. I haven't found any references (I'm sure they exist) on a best practice for managing the following flow: Set sensible, lightweight default values on initial render. Kick off one or more async processes to make longer running function calls. Receive the values in the LiveView, and update the assigns. As always in Elixir, the tools are powerful, and theres many ways to accomplish this. Spawn a linked, or unlinked process. Start a supervised, or unsupervised Task. Make a call to a GenServer, and have it send a mess
Read more

Write Admin Tools From Day One

Image
UPDATE:  I gave a talk expanding on this blog post at EMPEX NYC 2023 . The Problem Writing useful features for your users is key to a successful product.  It makes sense then that you should maximize your time writing features for those users.   This approach is very effective at the beginning of a product's life, but over time, you may find you are spending more time maintaining the product that developing it. Some of the biggest development time sucks can be: Tracking down the cause of unexpected behavior. Fixing data. Answering user, or team member questions. Running maintenance scripts, or other ad-hoc tasks. The "Oh #&@$" Solution These small support tasks start to add up, and there is no easy way to offload the work to product, or support.  You and your development team reach a breaking point where you must start prioritizing administrative tools. Unfortunately, you will slow down your new feature development even more in the short term.  It will take time for t
Read more

Custom Kaffy Styling

Image
I recently gave a talk at Empex NYC ( link to talk ) on why you should be writing admin tools from day one .  In my talk, one thing I highly suggest is to make it very obvious what environment you are in when providing a web admin UI for your team.   We've been using Kaffy at SwayDM since the beginning.  At the time, you couldn't easily overwrite the styling.  I maintain a private fork of Kaffy for changes I've made, which included the ability to change the background color. I recently merged the past few minor Kaffy releases back into my fork, and saw that Kaffy now has the ability to provide Extensions which allow you to inject custom html, css and javascript.  I spent a little time making a custom CSS file to change the color of the Kaffy nav, and add a title which notes which environment you are in. For each environment, I have a static file for CSS styling overrides. kaffy-ext-local.css kaffy-ext-staging.css kaffy-ext-production.css defmodule SwayDMWeb.Admin.Kaffy
Read more