Making the Complex Simple
I thought it rather appropriate to make my first blog post be about making the complex simple, since that is the central theme of the blog.
What do I mean by making the complex simple?
In my mind this is the single most important quality of a software developer. The ability to take something that is complicated and too large to fit inside a skull and make it simple and understandable. This concept is applicable at many different levels of abstraction, just as the practice is.
For example: When we are writing code, what we are doing is taking a complex world and dissolving it to a simpler abstraction of rules which govern how it works. The world is often “fuzzy” and requires judgement and intuition. As developers we take that “fuzzy” world and make generalizations about it and make it concrete for our problem domain.
Taking it a step further, simply writing software or code is simplifying the complex world into black and white, but even that is complex. I can write a bunch of assembler code or even machine language and I may have technically made the complex world simple, but I may have actually made it more complex to the next programmer who reads my code. As a good developer, I would strive to make the expression of those rules of the system to be simple itself so that another developer or myself could easily understand this complex concept. This is what I mean when I say elegant code.
Being able to write code that is easy to understand or “fit in your head” is such a quintessential part to development that without that skill even the most genius developer is bound for failure. I would equate this with the difference between writing intelligent code versus wise code.
Simple vs complex is such an important concept that it transcends programming and really touches many areas of our lives. Think about your car. How simple is it to use such a complicated piece of machinery? There is a large amount going on which we don't know or care about when we drive a car, but someone came up with a simple interface which makes this really complex thing very simple. Consider Apple's success. I have had a smart phone since HP first came out with the IPac phone, but did I ever really use any of the features on the phone? Apple came along and took this complex interface for most of the competing phones and didn't make it stupider, they just made it simpler. In fact, they gave it more capabilities but made the user interface so simple to use.
If you are interested in finding out more about this mindset, I would recommend checking out Eric Evan's book, Domain-Driven Design: Tackling Complexity in the Heart of Software .