Software Is Really Never Finished

The idea of a finished software is ludicrous. Complexities of today’s digital world mandate frequently updated software.

Software Is Really Never Finished
Image created with Midjourney

I read this linkpost from Gruber about the beauty of finished software. Gruber was linking to this piece. As a passionate user of software, this article triggered a few thoughts.

I wonder if the idea of a finished software is even possible in today’s world. It’s a fascinating subject.

Craft is updated quite frequently
Craft is updated quite frequently

Consider how modern software and services are built using continuous integration and continuous delivery pipelines (CI/CD) in an agile development organization. The whole concept of CI/CD was partially put together to deliver bug fixes and new features faster, in an iterative matter. Continuously updated software is systematized under the umbrella of DevOps.

What is CI/CD in Software Development?

CI/CD (Continuous Integration/Continuous Delivery) is a software development practice that enables developers to integrate code changes into a code repository, build the code, test it, and deploy it quickly and reliably. It is a key part of DevOps, a set of practices that combines software development and operations to improve the speed and quality of software delivery. CI/CD helps to automate the process of software development and delivery, allowing teams to deploy faster and more frequently.

When Apple releases a new version of macOS, new features are available to the end-users and new APIs to the developers. Because of this relentless effort by Apple to move the software needle and support new hardware features, third-party software has to evolve, too. In this dynamic landscape, apps or software are never done. And I’m okay with it as long as we don’t take too many steps backwards with each release. I hate using an app that fails to embrace recently introduced operating system-level features, like Shortcuts or something even more basic like Share Sheets. I’m looking at you, Craft 👀.

We could try to elaborate a list of reasons for software updates:

  • Add, update or remove functionality;
  • Update the application’s internal third-party libraries and dependencies;
  • Adopt a new operating system feature (Apple Pay, Metal, Passcode);
  • Support a new hardware feature or a new device (Halide for iPhone 15);
  • Adopt new UI paradigms (iOS 7);
  • Update application non-executable assets (correct translations);
  • Adopt new platforms within an ecosystem (Catalyst);
  • Fix a security issue;
  • Conform to external rules and legislations (App Store’s new rule, GDPR, etc.);
  • Conform to a legal issue (cease to desist order, etc.);
  • Adopt a new or updated back-end service in the cloud;
  • Enable connection to a new app in the same app ecosystem (Photomator + Pixelmator);
  • For some optimization (app size, CPU consumption, memory consumption, network bandwidth, etc.);

As you can see, updates are mandatory in today’s complex and dynamic world. Otherwise, there might be something wrong with the developer.

When looking to add an app for any of my workflows, One of the first things I’ll consider is the history of updates. Unless it’s a straightforward and highly focused app, an app without recent updates is a red flag for me.

Tot, a simple text editor hasn’t been updated for a year.
Tot, a simple text editor hasn’t been updated for a year.

Oh, and one last note: did you know that Microsoft Word turned 40? Yet, it is still being updated after all these years. I find it funny bringing Microsoft Word here, as the original article referred to WordStar 4.0 as a good example of finished software.

As tools, software can’t always be compared to a hammer or a screwdriver. Software stands in a unique category of tools made by humans for humans, but a tool mostly in constant mutation.