Software Craftsmanship is about professionalism in software development.
It’s a mindset where software developers have taken the step to be responsible for their own careers, continuously learning new tools and techniques and continuously improving themselves.
Whatever you want to call it, an art, a craft, science, trade, at the end of the day, what we all care about is raising the bar of our profession and helping developers, including ourselves, to be professional software developers and not solely workers doing what they are told to do.
Manifesto
This excerpt is taken from Manifesto for Software Craftsmanship:
As aspiring Software Craftsmen we are raising the bar of professional software development by practicing it and helping others learn the craft. Through this work we have come to value:
Not only working software, but also well-crafted software
Not only responding to change, but also steadily adding value
Not only individuals and interactions, but also a community of professionals
Not only customer collaboration, but also productive partnerships
That is, in pursuit of the items on the left we have found the items on the right to be indispensable.
Let's go over each point and have a look at what they imply.
Not only working software, but also well-crafted software
Just because software is working software doesn't mean it is good enough.
Imagine a four-year-old application. One that has no tests, no one knows exactly how it is working, the code is full of technical terms instead of expressing the business domain and functions/methods are extremely long and being responsible for multiple things.
The problem we have when working with such an application is fear. Fear of touching the code, because no tests are in place, we don't even know if the code is getting better or worse.
By the way, if you do happen to work with legacy code, check out one of my previous articles about working with legacy code.
Working software isn't good enough. Well-crafted software is good enough.
Software that developers can easily understand, has tests in place, clear and simple design, and business language well expressed in the code.
This excerpt is taken from the book The Software Craftsman:
In order to evolve applications, developers must not shy away from changing them. Using Test-Driven Development, simple design, and expressing the business language in code are the best ways to keep a healthy and well-crafted code.
Not only responding to change, but also steadily adding value
Software projects are usually a massive investment.
If you think about it, not just all the developers working on it, but all the other roles as well.
As with any normal investment, companies will want a return.
When we talk about steadily adding value, we aren't just talking about adding features or fixing bugs. This is also about continuously improving the existing code, both the production and test code.
I have been in situations myself, where you are supposed to touch code that you don't really want to, mainly because you don't understand it, it's complex and not simple, and hence you start fearing it.
Also, if we don't improve the existing code, as time pass, it will become more difficult to work with it, meaning, requiring more time to change existing behavior and add new features, more time is taken to deliver software to our customers.
I wrote an article about the art of improving the existing code and the importance of it.
A very poor return on investment would be for a company having to rewrite their software a few years after having developed it.
This excerpt is taken from the book The Software Craftsman:
Increasing the software lifespan, and keeping the ability to change it fast enough, is our main mission. Good software design, automated testing skills, and passionate and talented developers are essential for achieving that.
A paraphrase of a Boy Scout rule (first applied to software by Uncle Bob) states that we should always leave the code cleaner than we found it.
Not only individuals and interactions, but also a community of professionals
Sharing and mentoring are at the core of Software Craftsmanship.
Be humble and be willing to share your knowledge with less-experienced developers, by mentoring and inspiring them.
This excerpt is taken from the book The Software Craftsman:
Knowledge, ideas, successes, and failures must be shared and discussed within the community in order to move our industry forward.
Craftsmen are not developers who aren't humble enough to learn from others, or willing to share their knowledge by mentoring and inspiring less-experienced developers.
Be humble, kind and patient.
This excerpt is taken from the book The Software Craftsman:
Learning from each other is by far the best way for us to become better. Writing blogs, contributing to open source projects, making our code publicly available, becoming part of our local communities, and pairing with other developers are some of the ways we can contribute to the greater good of our industry.
Not only customer collaboration, but also productive partnerships
We believe in partnership and professional behavior.
Unlike factory workers, software craftsmen don't just turn up to work on time, keep their heads down, and do what they are told to do. We always strive to actively contribute to the success of the project, questioning requirements, understanding the business, suggest improvements, and productively partnering with our customers or employers.
Successfully delivering high-quality software and having satisfied customers are crucial for software craftsmen.
By having a productive partnership, we mean providing value to our customers at all levels such as:
Improving their processes
Providing them with more viable options
Helping them to remove unnecessary bureaucracy
Understanding their business domain
Questioning their requirements in relation to the value they provide
Software craftsmen do more than code-related tasks, developers who don't, they aren't craftsmen, they are factory workers in disguise.
Conclusion
Strive to be a professional, not a factory worker in disguise.