Craftsmanship is not the prerogative of a few creative artists… It has been moving out of the world of objects and into the computer world for a few years to help developers produce better quality software. Meet Bayrem Jrad, consultant at Wemanity, who draws back the veil on the mysteries of “software crafting”.
1. Software craftsmanship for dummies
Although agility has been established at the heart of companies in recent years, it has hitherto been embodied more by implementing frameworks such as Scrum or creating new business professions such as Scrum Master or Product Owner. In both cases, the focus was on providing maximum added value to the customer. But where agility focuses mainly on processes and methods to achieve this quality, software craftsmanship gives the human element and developers a central place in this ecosystem.
The notion of software craftsmanship first appeared in 2008, under the impetus of Robert C. Martin, an American software engineer and co-author of the agile manifesto (2001). This movement, which originated in the software world, was inspired by the concepts developed in a book published in 1999 by Andy Hunt and David Thomas entitled “The pragmatic programmer: from journeyman to master“; a real bible for all computer programmers. The latter mentions that good software should be both functional and well designed, which requires a return to artisanal methods in IT development, notably by emphasising the creation of a professional and collaborative community that can collectively create added value.
2. Code that is more flexible and open to continuous improvement
In practical terms, this software craftsmanship is reflected in the writing of the code, so that it can be made flexible enough to evolve rapidly according to the client’s needs over time. Code that is simple and intelligible enough to easily accommodate later modifications, or even to add new functionalities, as Bayrem Jrad, a consultant at Wemanity, explains: “To give you an example, if we want to create a road to go from city A to B, we can either decide to build a simple motorway from the outset, or we can anticipate future branches off towards other cities upstream of the project, and therefore leave the main road flexible enough to not make the task more complex in the longer term.”
And the road metaphor is apt in explaining the long journey that leads to software craftsmanship. The latter represents the software continuity of agility by proposing a more flexible code from its inception, thus saving development time and avoiding “legacy code”, which carries the technical debt of a too rigid code that cannot really be changed. In the end, the product delivered to the customer has a longer lifespan and remains open to change at a lower cost, as confirmed by Bayrem: “Nowadays in the software industry, when you put a new team in place to modify a piece of code and develop new requirements, it can cost the company more money.” Because what has already been designed is not always open to modification or extension. With software craftsmanship, we are implementing practices that are part of a continuous improvement process”.
How to put software craftsmanship into practice?
3. How do you become a “software craftsman” ?
Software craftsmanship is a mindset that needs to be fostered by a particular corporate culture and practices. The software craftsman works like a tightrope walker who constantly fluctuates between satisfying the user’s needs and creating quality code. To encourage the deployment of this type of attitude within your organisation, it is essential to cultivate an environment in which developers can benefit from a culture of continuous learning and sharing, as Bayrem at Wemanity said: “Before, I was trying to follow best practice, but I didn’t know it. I discovered the craft of software at Wemanity, where I was able to access specific training and a network of experts that helped me become a software craftsman.”
This ecosystem is conducive to the development of collective intelligence, which is also based on practices such as dividing projects into modules so that parts can be corrected without reviewing the whole project and the frequent use of tests in integrating the various modules. “To implement the values of software craftsmanship in software development, we use methodologies such as TDD (test-driven development), which consists of writing the code by following tests. Within the framework of implementing a human resources management application, several criteria can be defined that will determine that in order to validate a leave, it is necessary to have a balance and the approval of one’s hierarchical superior. In the code, we will ensure that the desired functionality is guided by tests …” Bayrem adds.
And if TDD does not suit them, those crafting the software benefit from a well-stocked toolbox to carry out their work, including:
- BDD (Behaviour Driven Development or programming oriented behaviour) which promotes collaboration and communication between developers, engineers and non-technical stakeholders during the development of an application to formalise a common understanding of how the application must behave.
- DDD (Domain Driven Design), which encourages dividing the architecture of the application into several Domains to organise the source code more, give it business expressiveness and create a more flexible field of communication between developers and trade experts
- KISS (Keep It Simple, Stupid or Keep it simple and stupid) which advocates creating code simple enough to be maintained for as long as possible and be reviewed effectively in the future.
- YAGNI (You Ain’t Gonna Need It), which means not developing unnecessary features and thus moving projects on more efficiently.
- DRY (Don’t Repeat Yourself), which seeks to automate and optimise what has already been done within the code and avoid repeating the same code twice in the same system.
4. The software craftsmanship manifesto
More than yet another method of software programming, software craftsmanship must also correspond to a commitment on the part of your employees to be inspired by the values of the software craftsman manifesto:
- Not just software, but well-designed software
- Not only adapting to change but also constantly adding value
- Not just individuals and their interactions, but also a community of professionals who are open to criticism
- Not just customer collaborations but productive partnerships
A philosophy that favours collaboration between developers and a long-term partnership with the client and the creation of constantly added value, as Bayrem asserts. “From an organisational point of view, software craftsmanship is a necessary upfront investment that will allow us to avoid unnecessary investments further down the road. This allows better quality products with greater end-customer satisfaction.”
5. What is the difference between software engineering and software craftsmanship?
Finally, one may wonder what really distinguishes software craftsmanship from simple software engineering. And there’s a fine line between them … While software engineering focuses on the end goal of programming software that must be reliable and efficient, in software craftsmanship, we will focus more on the artisanal (and therefore qualitative) part of its design and the skills of the craftsman. In this sense, the software craftsman conceives his or her program as an art that emerges and evolves over time, which leaves greater flexibility in its development.
However, although the two disciplines seek to satisfy the customer and deliver a quality product with a minimum of risk, software craftsmen will seek to establish good practices based on their experience, which they knows is moving forwards and evolving, as Bayrem recalls: “The only constant in app development is change.” A major difference with software engineering, which is acquired at the cost of a little organisational and human effort within your teams, “Getting into the software industry requires a lot of collaboration and communication among employees, but above all, great openness to criticism and feedback”.
In a world that constantly has to face new digital challenges, it is crucial to develop efficient and scalable applications over time. A mission that is only possible if we rethink the developer’s place in the project ecosystem. By promoting the artisanal part of the profession, software craftsmanship not only redefines its landscape but, above all, makes it possible to place it at the heart of a quality approach that meets the company’s contemporary constraints.