Simplicity requires complexity

A major goal of a programmer is to try to map a complex analog world in a digital form. It’d be easy to follow in complexity’s footsteps and provide shoddy solutions to these problems. We have to remember, though, that simplicity is essential to the success of an application.

Jack Dorsey, founder of Twitter, also founded Square, which is a service that allows anyone to take credit card payments via their phones. The problem is complex – allow anyone, anywhere to take digital payment from someone else. He took that complex problem and provided a simple, elegant solution:

So we have built the simplest way to accept credit cards. It’s a little tiny device that we give away for free, and you just download some so wars from the app store and plug it in to your mobile phone or iPad and suddenly you can take credit cards. So if you’re a tax accountant or a lawyer or doctor or even a hair stylist, you can now accept credit cards.

Square has ballooned into a massive company and it’s all due to the ease of use of their app. You plug a free device into your phone and start swiping cards. That’s it. Had they charged for the device and had complex billing rules the company would be no where near as big as it is today. Simplicity fuels them.

Enter the Laws of Simplicity

The Laws of Simplicity

John Maeda wrote about the 10 Laws of Simplicity which are a fantastic intro to simplifying design and are relevant in many more markets than just computer science. Although all 10 laws are good, my favorite is definitely Law #5: Differences:

Simplicity and complexity need each other. The more complexity there is in the market, the more that something simpler stands out.

Which he follows up by saying:

Nobody wants to eat only dessert. Even a child that is allowed to eat ice cream three meals a day will eventually tire his sweet tooth.

I have this same argument with my wife (although not about dessert (okay, also about dessert)). She always says how she would love to live in Hawaii; my response is always *But where would we vacation?*Too much of a good thing is a bad thing, and simplicity is a good thing.

Humans need contrast in order to realize what’s good and what’s bad. My mom once told me that not everyday can be a good day. You need the bad ones to truly appreciate and acknowledge the good ones. The same goes for complexity and simplicity.

Employing simplicity with complexity

John implies that you have to compare your solution to complexity in the market and I agree with him that it is important. I would argue, though, that complexity within your application is equally important. One way to do this is to make things you want your users to do easy and things you don’t want them to do hard.

GitHub employs this technique very effectively. For instance, to render a nice readme about your repository you just include a readme markdown file in the root of the repo. Simple. To delete a repository, however, you must go through the settings find the delete option and type in the full name of the repo. Much more complex than the readme.

Always strive for simplicity, but remember to always pepper in a little complexity with it. It will help users remember why they use your app in the first place.