Why talk about the book “The Software Craftsman“?
This book discusses topics I find important in a clear-sighted and pragmatic way. For example, the role of a developer, how to approach the profession, or continuous improvement. In the book's preface, Robert Martin describes it as “a fascinating alternation between autobiographical anecdotes chronicling the author's vast experience and authoritative recommendations based on his experiences.” This article will summarize the key points that seem paramount to me.
What is Software Craftsmanship?
The definition of this concept is subject to debate within the community, but the author offers the following personal definition: “A long journey towards mastery. A mindset where the developer chooses to be responsible for their own career, constantly learning new tools and techniques and seeking improvements. Software craftsmanship aims to place responsibility, professionalism, and pragmatism at the center of development.”.
In the prelude, the author presents the synergy this movement has with Agility. According to him, these methodologies allow for “building the right product” and doing so as a “Software Craftsman” allows for “building it right.”.
Integrating Agility into a development team sometimes encounters pitfalls. Many companies have faced difficulties during radical transformations of their processes via Agile methodologies. According to Sandro Mancuso, Agility should not be questioned because a methodology only interacts with processes and people. Within this framework, it is the company culture that must be modified according to the values of Agility (see Agile manifesto) and the spirit of software craftsmanship.
In parallel, the software craftsman manifesto is as follows:
“As aspiring Software Artisans, we raise the bar for professional software development through practice and by helping others gain expertise. Through this work, we have come to appreciate:
Not just functional software, but also well-designed software.Not just adapting to change, but also constantly adding value.Not just individuals and their interactions, but also a community of professionals. Not just collaboration with clients, but also productive partnerships.
That is to say that by searching for the elements on the left, we found that the elements on the right are indispensable.”
At first glance, these points seem a bit obvious. Through his book, the author clarifies several situations where some of these points can be forgotten and refines his view of these different ideas.
Software Craftsmanship emphasizes good practices because it focuses on the quality and craftsmanship of software development. It draws parallels to traditional crafts, where mastery is achieved through dedication to the craft, continuous learning, and the application of time-tested techniques. Here's why it highlights good practices: * **Focus on Quality:** Craftsmanship prioritizes building high-quality, maintainable, and robust software. This inherently leads to adopting and refining practices that contribute to this quality, such as clean code, thorough testing, and effective design. * **Professionalism and Responsibility:** Software Craftsmanship promotes a sense of professionalism and ownership among developers. They are seen not just as coders, but as artisans responsible for the end product. This mindset encourages them to invest in learning and applying best practices to ensure their work is sound. * **Continuous Learning and Improvement:** Like any craft, software development requires continuous learning. Craftsmanship encourages developers to constantly seek out new knowledge, experiment with different techniques, and learn from the experiences of others. This ongoing journey naturally leads to the adoption and popularization of effective practices. * **Sharing Knowledge and Mentorship:** The community aspect of Software Craftsmanship is crucial. Developers are encouraged to share their knowledge, mentor junior developers, and collectively improve their skills. This sharing process often involves discussing and promoting established best practices. * **Sustainable Development:** By focusing on good practices, Software Craftsmanship aims to create software that is sustainable over the long term. This means avoiding technical debt, making the codebase understandable, and designing for change. These principles are directly tied to adopting practices that facilitate maintainability and adaptability. * **Pragmatic Approach:** While it values craftsmanship, it's also a pragmatic movement. It doesn't advocate for overly theoretical or dogmatic approaches but rather for practices that demonstrably lead to better outcomes in real-world development scenarios. In essence, Software Craftsmanship acts as a conscious effort to elevate software development from a mere task to a respected profession by championing the principles and techniques that have proven effective in creating excellent software.
The concepts of continuous improvement apply to both the general work of a software craftsman and their technical tasks.
Like a lawyer providing personalized advice, a developer will explain the ins and outs of their work, as well as the pros and cons of their technical choices.
Being professional and satisfying your client doesn't just mean developing the product exactly as they request. It also involves taking on the role of advisor and communicator by helping the client understand their goals and how to achieve them. In his book, the author argues that it's important to embrace this role for profitable and effective collaboration for everyone.
Regarding technique, he suggests above all being pragmatic. Implementing tools or practices has no intrinsic value but should enable a task to be accomplished optimally. If that's not the case, it's probably not the right tool.
In terms of practice, he emphasizes two concepts that resonate deeply with me: refactoring and Test-Driven Development.
What are these two concepts and what are their connections to development?
In this book, I found a very good argument to justify refactoring in the form of the following metaphor: “Like a garden, code needs constant maintenance. [...] With basic and regular maintenance, the garden will always be beautiful, but if we neglect it, the effort required to restore its splendor will be much greater.”
This isn't about “fixing bad code” but simply staying up-to-date with the latest standards. It's not about “fixing a flawed design” but rather ensuring that new features are added while considering the current environment. Then, updating the latter if necessary to maintain an impeccable design.
Regarding Test-Driven Development (TDD), the main advantage is ensuring that the expected outcome of a feature aligns with the client's expectations. Furthermore, it also allows for a more direct approach to coding, reducing the risks of “over-engineering” (excessive complexity in code design).
Furthermore, overly complex code tends to be difficult to test, which forces the developer to re-analyze their code's design to simplify it. TDD shortens the testing feedback loop, much like Agility does at the business level. Thus, our code is cleaner and more easily maintainable and testable.
How will “The Software Craftsman” influence your career?
For a young developer, understanding the ins and outs of their role and how to fulfill it professionally is one of those things that isn't learned academically but rather through experience. Furthermore, the observations noted in this book struck me as interesting. They will now be part of what I consider when creating my own vision of things.
Get the book by buying it here
Written by Lionel Mottet & Charline Pennisi
