Software Made Simple has been my slogan for as long as I've been developing software. Many years ago I did a presentation about this as a "lightning talk" in a conference keynote. Here's an updated version.
Simplicity is a popular topic these days. But other than being cool, what are some reasons you should put more effort into simplifying your software? Because simple sells. Here are some examples:
Perhaps the best known case of taking something that was complex and providing a simple alternative is the iPhone. Back in 2007 before the iPhone came out, nearly everyone had a cell phone and nearly everyone hated their cell phone. Apple took a step back and created a phone that anyone could use. In fact, when the iPhone was first released we stopped at an AT&T store to check it out. My daughter, who was 5 years old at the time, was able to pick up the iPhone take pictures, play music and make a call without us showing her how. She certainly couldn’t do that on my Samsung cell phone.
Sure, Apple took a bit of flak for the iPhone not having all the features that some expected for a smart phone. But it had enough and the lack of features certainly didn’t hurt sales. Now Apple is the largest company on the planet and has just recently passed $1 trillion in market cap, largely based on the iPhone, so it seems like their vision worked out OK for them.
I love Sudoku. It’s really simple to learn. You can explain the rules in less than a minute. It became a phenomenon precisely because of this.
I’ve convinced more people to get a Mac by showing them the Photos app (and iPhotos before that) than any other reason. People love taking pictures and Photos makes it simple to manage your pictures. It eliminates any fear of editing your pictures because you can always go back to the original with just a single click.
First it was Dropbox, which made it stupidly simple to share files across your devices. Plus it also worked as a sort of backup for many people without a lot of files. And it was free to use (for a small amount of storage). Others jumped on the bandwagon and now you also have OneDrive and even iCloud Drive. BackBlaze and other cloud backup services took off from here and provide unlimited backup storage for your files, all handled automatically without you having to do anything.
I particularly like this example. Nintendo took what many thought was quite a risk by releasing the Wii in 2006: a game system that was much less powerful than either the XBox360 or the Playstation 3. In the end, Nintendo was proven right. They reasoned that most people wanted to have a game system that was fun and approachable more than one that was incredibly realistic and complex. They messed up this philosophy with the Wii U by making things more complex but got it right again when they introduced the Switch.
For your users, simple means one thing: make it easy to use. This can mean a lot of things to different people but the key thing to keep in mind is that your software should be approachable.
Your users don’t want to read manuals or go to training in order to effectively use your software. They want to just figure it out as they use it. This means your software needs to respect them. It should be easy for them to learn how to use it. Most importantly, it should be easy for them to correct any mistakes they will make.
Because, rest assured, your users will make mistakes. When the user no longer fears making mistakes they’ll enjoy using your software. And then you’ll start getting feedback that says: “Your software is so easy to use. I love it!”. Trust me, you’ll enjoy that, too!
Simple is Hard, as in “hard for you, the developer”.
To be blunt: it’s going to take a lot of work for you to create something that’s simple. You’ll spend significant time thinking and not actually writing any code. This can be difficult for a lot of developers. After all, they equate productivity with typing. But realistically you probably will spend more time thinking than coding.
When it comes to simplicity, your design matters. A lot. You can’t just bang out a solution, figuring it out as you’re coding. Sure, you’ll end up with something and it may even be useful. But it most certainly won’t be simple.
A really good reason to not spend a lot of time coding is so that you can be more flexible. If you come up with a new, better and simpler design, you’ll be more likely to throw away your old design if you didn’t spend many hours coding it up. It’s just a fact. We all get attached to the code we write.
Be simple. You will appreciate it.
- Less stress for you
- Less stress for your users
- Less code to write, which means less bugs
- Less features, but the right ones
- Less complexity
- Less buttons
But, believe it or not, it’s a lot more work to do less. As the famous quote from Blaise Pascal says: “This letter is very long because I had no time to make it short.”
Things that are simple are:
- Used more
- More useful
- More fun
- Bring you more customers
- Get you more sales
So you can go on more vacations!
By virtue of having software made simple, you gain a few efficiencies. Perhaps most importantly is the ability to release your software quickly. Frequent updates to software, particular when it is in the early stages are a great way to get user feedback, show your commitment and get people excited.
A common way to keep working efficiently on core features (and not bloated features that not everyone needs) is to build a way to allow your users to configure the software to meet their needs. This can range from simple preferences that the user can tweak to more advanced configuration files and plugin support.
Simple doesn't mean just do less. It really means be focused. Know what you need to do by understanding your customers. Do what they need, not what they think they want. Believe it or not, these are often two very different things.
Customers don’t understand software; you do. It is your job to find out what they truly need to do.
Find Your Niche and add value, not features. Dare to be different because you don’t do what everyone else is doing.
Eliminate ways for your users to make mistakes. This means provide some way for users to be able to "undo" a change. Design for the novice, but don't alienate your power users.
And don’t ask the user silly questions: Are You Sure about this or that?
Just make reasonable assumptions that the user can change (or undo) if they want.
Only write the code you need, don’t write the code you might need. Less code means less bugs and less to test. You can always write it later, when you need it.
Refactor often as technical debt can kill even the best intentions.
And test often. Don't just "ship it if it built". Use unit testing, continuous integraton and try test-driven development.
Lastly, master your tools. Whatever tools you use be sure to master them so that you are as efficient as possible.
If you like simplicity you might also want to check out development tools that themselves value simplicity. And Xojo does just that. With Xojo you can make apps for Windows, Mac, Linux, Raspberry Pi, iOS and the web from a single, focused and simple IDE and programming language. It might prove useful for your next (or current) project.