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 and experience, and on top of that, software development keeps changing and mutating all of the time.
There are forces of software development that remain the same regardless of technology. They are timeless and do not change. To fully control the software that is our creation, we professional software developers must master the five disciplines (which all mysteriously start with the letter “D”).
1. Design (and Architecture)
This is the act of deciding what your software will look like before it’s even written. Design is also a balance between what we know now, what we expect to happen, and some wishful thinking. Design can be abused by overthinking. Over-design happens when developers just want to use the latest technology or when someone reads a good book about design patterns and completely misses 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 birth to unmaintainable ugly that later becomes 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 fit 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 becomes reality with the keyboard (and sometimes the mouse).
It is what software developers do (hence the name). However, it’s more than hitting your keyboard as fast and as hard as you can. It’s about how clearly a developer can express complex and sometimes contradicting ideas using code.
A seasoned developer knows how to employ his or her development environment of choice to create elegant code. He or she knows the keyboard shortcuts and knows how to refactor and navigate the code. The real tool of a good developer is the ability to learn. New technology, new paradigms, new programming languages, all bring 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 continues on working.
An overlooked art of finding and fixing past mistakes. Debugging is rarely talked about but carries a lot of power in the hand of a real professional.
There’s more to debugging than pressing F10 countless times. Mastering debugging is hard. A bug catches you when you least expect it. When debugging happens, a developer is most likely concerned with getting back to 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 the 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 exists that happened during conditions that are no longer valid. A new set of tools needs to be used under pressure from peers and managers while time runs out.
Your code does not begin and end 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 environments on the way.
Deployment goes hand in hand with automation. Your code should be built and tested on another machine and if you get it right, update the next machine all the way to the production environment.
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 deadline is the beginning and end of every software project. Having 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, of prioritizing and dividing 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 Ds of software development. Now go write some code!