Needless to say, computer science is still in its infancy but has made incredible strides in just over half a century. During this time, it's striven to get the respect it deserves as a disciplined subject. Even just 14 years ago, when I started my undergrad in this subject, I recall reading articles debating whether it should be called a science at all. Gladly, I do not see this argument thrown around much anymore. From Knuth's classic work in The Art of Computer Programming to the wide-spread use of pure mathematics in describing algorithmic approaches, computer science has the proper foundations to join other respected sciences such as physics, concrete mathematics, and engineering. Like other sciences, computer science demands of its participants a high level of respect and pursuit of knowledge. But, unlike other sciences, it is difficult to enforce that its participants give it the level of respect it deserves nor pursue it with the same level of discipline that other sciences require. Consequently, the science behind software development is often neglected or not taken into consideration whatsoever. This becomes reflected in the widespread impressions that software is fragile, that accurate estimating is impossible, and that managing software development is largely undisciplined.
To improve impressions of mainstream software development - which, presumably, should be based upon the foundations of computer science - it comes upon the shoulders of each developer to educate him or herself with the knowledge necessary to give this discipline proper attention. Developers cannot push off this responsibility to management or "the priority setters." It is up to each of us to give software development the respect it deserves and educate those around us, accordingly. Helping to assist this cause does not require a masters degree in computer science, or even an undergrad degree (although I recommend it), but it does require a commitment to learn from the mistakes of experts that have come before us so as not to repeat those mistakes again. A former professor of mine, wiser than I, said that you will not be an expert in computer science until you have made every mistake possible. Fortunately, we need not make all of these mistakes ourselves as many have come before us to pave the way and leave behind the lessons they have learned.
Although there is no single best practice, practices do exist which embody the lessons learned from years of painful experiences and hard won insight. This is not to say that all the practices described are not subject to critique and improvement, but they do serve as a confident starting point for engaging in our own daily practice. Ignoring them outright, which is almost a norm within the world of software development, is an injustice to the science in which we say we engage ourselves. Structural engineers do not start designing a building's structure without first investing a large amount of time understanding engineering best practices garnered from centuries of engineering practices that have come before. Unfortunately for them, if they do not do this, lives may be at stake. Unfortunately for us, we do not usually have such pressures to commit the same level of care and attention to our own work. Furthermore, it is frequent that management does not support the time required for learning and executing ideal software development practices. Both of these disadvantages to software development can almost always be overcome by empowering software developers with the adequate education for implementing proper practices and methodologies. Fortunately for us as developers, this empowerment is in our own hands.
In a sense, this message is a call to arms for software developers to give our science the respect it deserves as expressed in our day to day work. We are engaged in a practice which the world is becoming more and more dependent upon; in all seriousness, there are few other sciences which will have as big an impact on the world in the coming century as computer science. The first step that each of us can take to better the integrity of our science and assist with its advancement is to pick up a book. Although not all are equal, key texts infuse in us the wisdom of many years of development and the expert knowledge garnered from many mistakes. What follows is a minimal course of reading for infusing such knowledge, becoming a better software developer, and giving computer science proper respect in your daily practice. I suggest that they be read, believed, and implemented in your daily practice. Works by authors such as Martin Fowler are not just books full of ideas that he invented, they are tried and true practices built upon the shoulders of giants which can serve as a platform for standing on the giants' shoulders, ourselves.
Foundational Texts
What follows are key texts that every OOP developer should read, without exception, regardless of experience or platform. The order of the list is the order that I suggest reading them. These texts focus mainly on writing better, maintainable code with a transition to solid object oriented design.
Apprenticeship Texts
These texts help one move from focusing on the code to seeing the implementation from a higher viewpoint and improving the integrity of the project as a whole.
Journeyman Texts
These texts move towards more "putting it all together," wrangling the software development process, and getting into the "science" behind computer science.
The Beginnings of Mastery
These texts help hone your skills along with improving the efficiency and effectiveness of your team.
Mastery Texts
Although not to be seen as compulsory as the above texts, what follows will assist in taking you into the realm of pure computer science. At the very least, they serve to demonstrate that our work has solid foundations in quantitative science.
With the above listing, I've attempted to de-emphasize emerging techniques, such as Software Factories or Product Lines, in favor of established better practices for improving the design, development, and management of software development for yourself and organization. Obviously, taking on these texts cannot be done in a weekend and requires years of trial and error in implementing the techniques implied. But I assure you that embracing the ideas discussed will dramatically improve you as a software developer and help move your practices closer to the realm of disciplined computer science.
Billy McCafferty