On Tech

The Eternal Dream of Instant Software

By
Image of a blue and green parakeet sitting on top of a brown tortoise.

The product manager leading the engineers.

One of the good things about Aboard (they won’t let me write a newsletter about the bad things) is that it lets you organize a bunch of stuff quickly. As we work towards the next big release, one of the subjects that we talk about most is acceleration. How can Aboard help you do “software things,” faster, without writing code?

This led me to make a short list of the main accelerators in software over the last 30 years. Each category represents billions in investment and effort and huge communities. For example:

  • Simpler Code. Make an easier programming language that is simple to teach and learn. Logo, BASIC, Python.
  • Embedded Code. Put a programming language inside of something else. World of Warcraft can be extended with the Lua programming language. You can script the 3D tool Blender with Python. PHP was designed to work inside of HTML tags. The most dominant example here is JavaScript, which was born inside the browser.
  • Visual Code. Move stuff around, sometimes with boxes and arrows. Draw interfaces with your mouse. Frameworks like Visual Basic, or IDEs like XCode and Visual Studio Code—the dominant platforms of Apple and Microsoft, respectively, get you part of the way there, but they’re still mostly textual. There’s always an attempt to go all the way and get rid of text editing. This can work, but it tends to only work in niches, like audio engineering or visual effects, like Max for music composition, or the teaching language Scratch. (RIP Yahoo Pipes.)
  • Pure Code. Make a system that is less likely to fail, but requires more work up front. Haskell, TLA+—and the “Software that Never Fails and Can’t Be Hacked” of Green Hills Software. These are worth it when you’re writing an OS for your airplane. The White House endorses them.
  • Low Code. Give people tools to build a database, then offer easy ways to do things to the data in that database. Coda and Airtable are good examples here, as is Notion if you look at it a certain way.
  • AI-assisted Code. Tell the system what you want and it does it. This has been the dream for decades and there have been many attempts, but now…it’s actually (kind of) working with AI tools like CoPilot. Computers turn out to be okay at writing code after all.

Light a Candle or Recurse the Darkness

The funny thing with all of the above is that with success you are always, always, always back where you started. Simpler code becomes complex. Plugin languages become huge ecosystems. Visual coding tools involve tons of text files and special configurations. Pure code has to integrate with the impure world. Low code breaks over time like anything. AI code still needs to be debugged. There isn’t any “solution” to the above. We just talk about “legacy” and “tech debt.” 

It’s not just in software. Humans are always making huge messes while desperately seeking simplicity. You can build an industry telling people just to fold their pants. We’re desperate.

Going On the Grid

Software people making lists like the one I just made always leave out the spreadsheet, which has billions of users, makes intuitive sense, is the lightest-weight database available to most humans, and drives trillions of dollars in decisions every year. It’s not “real” programming though. Ah well.

Nonetheless, there is a huge range of human challenges related to listing stuff, tracking stuff, and organizing stuff in rows where spreadsheets represent the 90% solution. The remaining 10% is where humans get into the mix. I really do think this is an important way to think about software tools: How is this better than a spreadsheet? Is it faster? Simpler? More visual? Does it serve a special function (like making World of Warcraft easier to script)? More collaborative? Does it provide more structure and lead to fewer problems?

There’s another thing about spreadsheets that gets undervalued: They’re disposable. They sit in the folder and they don’t bug you to update. You can open one from 20 years ago and you’ll know exactly what’s going on. Zero surprises. It’ll still be an ugly pile of rows…but it’ll work about the same. We don’t celebrate that quality in code very often—it would be bad for business—but it’s great to do things and throw them away. Then you can move on to the next thing.