What is the secret to writing awesome software?

As an industry we’re very good at gravitating to new techniques, new tools, even new languages as we aspire to write even better software. And it’s pretty hard to argue against the results that are obtained by some - even if those results are sometimes harder for others to reproduce.

Look back at the history of innovations in software development. Structured design, functional programming, object orientation, SCRUM, Extreme Programming, test driven development and domain driven design, to name but a few.

Each of these was heralded with great hype, with early adopters achieving extraordinary results that seemed to promise a revolution in the field, lifting us all to new heights of effectiveness and efficiency.

However, reality never seemed to keep up with the hype. While the early adopters had amazing results, mainstream adoption only ever delivered incremental improvement, not a revolution.

So, what is the key to writing awesome software?

How can iOS developers consistently deliver awesome software even without many of the must haves (unit testing, continuous integration, domain driven design) that some consider essential.

Why does Phil Haack consider GitHub such an awesome place to work? Is it because they use unit testing, continuous integration and the like - or is it in spite of those practices?

I contend that the answer is both wonderfully simple and outrageously difficult.

Wonderfully simple because the answer is easily understood by one and all.

Outrageously difficult because it’s not a practice you can mandate, nor even easily measure.

So what’s the secret to writing awesome software?

To care.

If you want to write awesome software, you have to care about doing so. You need to care deeply about the quality of what you deliver.

You have to care about the code you write and take the time to ensure it works properly.

You have to care about the testing you do and ensure everything is well tested.

You have to care about your users interactions and optimize the application for their productivity, not your own.

You have to care about the build process and work to ensure it’s done the same way every time.

User stories, wireframes, source control, defect tracking, code generation, unit testing, test driven design, continuous integration, continuous delivery, ubiquitous automation, functional programming and the SOLID principles.

None of these are sufficient to deliver awesome software in themselves - but they form part of a powerful toolbox for those who care enough to try.


blog comments powered by Disqus
Next Post
Care about the User Experience  21 Jan 2013
Prior Post
Powershell Rocks  14 Dec 2012
Related Posts
Using Constructors  27 Feb 2023
An Inconvenient API  18 Feb 2023
Method Archetypes  11 Sep 2022
A bash puzzle, solved  02 Jul 2022
A bash puzzle  25 Jun 2022
Improve your troubleshooting by aggregating errors  11 Jun 2022
Improve your troubleshooting by wrapping errors  28 May 2022
Keep your promises  14 May 2022
When are you done?  18 Apr 2022
Fixing GitHub Authentication  28 Nov 2021
January 2013