The secret to Awesome software
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.
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?
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.