Software craftsmanship is a movement in the development community, embracing the individual and focusing on a developer's quality and skill. It draws heavy influence from the apprenticeship model of feudal Europe and Asia, providing a path to mastery where a developer progresses through mentoring levels to achieve better proficiency in their craft, writing great code, and, most importantly, delivering exceptional value.
While craftsmanship emphasizes the developer's skill level and the quality of the code they produce, this increased focus on the individual can sometimes make us forget the real purpose of what we are trying to achieve. When delivering working software that yields continuing value to the customer, it is critically important to maintain our end goal's proper perspective while still preserving the highest degree of excellence in our work quality.
Meet Jon. Jon is a developer. Jon likes his job but scoffs at all the "new" libraries, frameworks, and technologies. He is perfectly comfortable with his current skill set. However, the world is not static, which is especially true in software development. In a state of constant flux, honing your skills is as essential as having them at all. Craftsmanship focuses primarily on personal growth via apprenticeships and typically fosters a culture conducive to passionate people that are in constant pursuit of improvement. The apprenticeship model provides a path to mastery, yet no destination. This perpetual state of one's advancement of their skills forges a way of writing better code.
Notice that my description of software craftsmanship focuses on the mastery of writing "good code" and not "good software." This subtle distinction is incredibly profound. It hints that better code does not necessarily translate to better software.
Building a skyscraper is hard. A mastery of mechanical and civil engineering, landscaping, interior design, and many other intersecting disciplines are required. However, regardless of how masterfully architected or beautifully engineered, it is utterly useless without exterior doors. The only thing that matters is whether it meets the people's needs using it.
Writing software is also challenging. Although creating a skyscraper without doors seems quite unlikely, it is not far-fetched to develop software with features that do not meet customers' requirements. Writing software is hard; writing software capable of providing continual value to end-users is even more challenging.
It is true that whether building skyscrapers or developing software, meeting the end-users' needs is above all else and should always be in focus. However, much like focusing solely on the craftsmanship will not likely yield the desired result; maintaining only a vision of the solution will also fail. A skyscraper that is not built correctly by skilled workers is as useless as one without doors.
Software craftsmanship is not merely shifting the focus from the software's value to the quality of code. Instead, it is a means to an end, a mechanism to achieve good working software. Without a vision, there is no path forward. Without craftsmanship, there is no means to move forward along that path. A software's value and the quality of craftsmanship are not divergent. In fact, to the contrary, these concepts are complementary, with each as intrinsic to good software as the other.
Craftsmanship is an arduous journey without a final destination. However, there are regular exercises to get you started. First, practice by doing a code kata every day. Each kata should take no more than 30 minutes to 45 minutes of your time. Dave Thomas has a great place to start with code katas at codekata.com.
Empty your cup, or, in other words, be willing to begin again. Regardless of the years of experience accumulated, craftsmanship teaches the pursuit of improvement, and that mastery is not static; instead, a continual work in progress. You cannot refill your cup until you have emptied it of its contents.
Do not be afraid to fail. Failure is nothing more than an opportunity to improve. Embrace failures as learning experiences instead. If you cannot fail, it probably isn't worth doing.