Warning: Do not take the following post too seriously
The software development world is governed by many forces beyond our control. There's so much to do and so little time, there’s so much to learn an experience and on top of that it software development keeps on changing and mutating all of the time.
There are forces or rather aspects of software development that remains the same regardless of technology. Those are timeless and do not change. And so to fully control the software which is our creation a professional software developer must master the five disciplines all which mysteriously starts with the letter ‘D’:
The act of deciding what your software look like before it’s even written. Design is also a balance between what we know now, what we expect to happen and some of our wishful thinking. Design can be abused by overthinking, over design happen when developers want to use the latest technology or by someone who has just read a good book about design patterns and completely missed the point.
A good software design is understandable, maintainable and flexible. A good design is easy to change as requirements are added, bugs are found and customers change their mind. Design can be created using a pen and a napkin or grown over time using tests and lesson learned. There are projects without architects but very few with architecture - they are a mess – the lack of a guiding hand and clear development path gives births to ugly, unmaintainable ugly which later become a story to frighten junior developers in years to come.
A good developer knows how to design enough, and can choose the right tools and technologies that best fits the task at hand.
This is the act of writing the code. Some think that is the only thing that software developers are good for.
Writing software starts at the developer’s mind and become reality using the keyboard (and sometime the mouse).
It is what software developers do (hence the name). But it's more than hitting your keyboard and fast and as hard as you can. But on how clearly a developer can express complex and sometimes contradicting ideas using code.
A seasoned developer knows how to employ his development environment of choice to create elegant code. He knows the keyboard shortcuts and knows how to refactor and navigate his code. But the real tool of a good developer is the ability to learn. New technology, new paradigm, new programming languages all of which are more tools to use.
Software development is more than just writing code. It's making sure that code works and employing the right methodology so that that code continue on working.
An overlooked art of finding and fixing past mistakes. Debugging is rarely talked about but carry a lot of power in the hand of a real professional.
There's more to debugging than pressing F10 countless times and mastering debugging is hard. A bug catches you when you least expects it. And when debugging happens a developer is most likely concerned about getting back to his work than finding ways to reduce the time and pain of trying to solve yet another issue no one has thought about.
In order to be good at debugging a developer must understand his code top to bottom, as well as how that code interacts with other parts of the system. Debugging can require finding information that no longer exist that happened during condition that no longer valid. A new set of tools need to be used, under pressure from peers and managers while time runs out.
Your code does not begin and ends on your machine. In order for clients to use your code they need your code to magically move from your machine all they way to the client's passing testing and staging environment on the way.
Deployment goes hand in hand with automation. Your code should be build and tested on another machine and if you get it right - even update the next machine all the way to the production environment or easily downloaded installer.
Although some developers think that deployment is none of their business. A smart developer will learn a lot by participating in the journey of his code and understand valuable lessons while contributing to the overall success of the project - in ways that transcend "just writing code".
The beginning and end of every software project. No deadlines sounds like fun but without deadlines there is no project. The art of deadline is also the art of trying to estimate work, prioritize and divide tasks to create an iterative progress that guarantees that even if the project won't be finished on time - at least your client (and boss) will be happy.
So there you have it - the five D's of software development. Now go write some code!