It’s an ideology/mindset about professionalism in software development. it promotes technical practices and ways for developers to get better at writing good and well-crafted code, and the idea that developers should do far more to help their clients than just writing code.
It helps developers and companies to do the thing right.
”How it is done is as important as getting it done."
"Software craftsmanship is a long journey to mastery. It’s a mindset where software developers choose to be responsible for their own careers, constantly learning new tools and techniques and constantly bettering themselves. Software Craftsmanship is all about putting responsibility, professionalism, pragmatism, and pride back into software development.
Software Craftsmanship is about professionalism in software development.”, - Sandro Mancuso
There is no such thing as a senior or junior developer. Developers may be very experienced in something, but totally inexperienced in something else.
Companies are demanding professional software developers and not just cheap coders who do whatever they are told to do.
Being good at writing code is the minimum skill expected from software professionals. Testing, analysis, ability to understand the business, good communication, and a more extroverted personality became part of the skill set that software professionals need today.
Attitude
If we think that a piece of code we wrote some time in the past is still good enough today, it means we didn’t learn anything since.
For us, software craftsmen, caring about and being proud of the work we do is a given. Constantly finding ways to become better professionals is a lifetime commitment. Satisfying and helping our customers to achieve what they want to achieve, in the most efficient way, is our main goal. Sharing our knowledge with less-experienced software craftsmen is our moral obligation.
You own your career
You must invest in your own career. Clients pay professionals for a good service and to solve their problem. They pay your for your knowledge and skills. Clients don’t pay professionals to learn.
You should not expect that company will invest in you. But if they do so, it’s a bonus and win-win situation for both parties.
Keeping up to date and constantly getting better at what you do is key for a successful career as a software craftsman.
Employer/employee relationship
Top-down relationship does not work well in software development.
Software professional should not be a factory worker that is doing only what he told to do. You need to be a professional, be involved and contribute to the business, provide options and solutions, offer the best service in implementation, technologies and quality of your work.
It doesn’t matter if you are a permanent employee, contractor, consultant of a developer in an outsourcing company. The relationship between you and your client should be seen as a productive business partnership.
Keeping yourself up to date
Reading books as a software developer
Read blogs. They are a good source for a personal experience. But may be written without research or deep thought, and present some misinformation. So be cautious.
Technical websites may be a good source to know about what’s trending in the market.
Follow people that thought leaders of the industry, specific technologies.
A lot of practice
The more we practice, the more comfortable we become.
When practicing, focus on writing the best code you could possibly write. Take as much time as it needs.
Katas can be used.
Pet projects may be the best way to learn and practice. You control the requirements and what practices, technologies you want to apply.
Contributing to open source projects is also a great way to practice. Allows to see great developers in action. Also, a great way to raise your public profile.
Socialize. Maybe try to find local user groups or technical communities.
Try to always create opportunities where you can learn something new you don’t know.
Create time to learn.
Learn how to say no
Often we have tight deadlines and a lot of pressure to meet them. Agreeing to them usually ends up very bad: production is full of bugs, clients are unhappy, trust disappears.
Professionalism means being honest with ourselves, with our teammates, and with our managers and customers.
Saying no to such unrealistic requirements is a sign of professionalism. Don’t try to be a hero. Instead provide alternatives, negotiate.
By providing alternatives we are showing our commitment to solve the problem, give our best shot at it.
Being professional and satisfying our clients does not mean doing everything they ask us to do. Our job is to help our clients to figure out what their real needs are and also advise them on the best way to approach them. A professional has ethics, and a code of conduct. A good professional would never do something that could be harmful to a client just because the client is paying for it. Clients very rarely understand the full impact of certain decisions on a software project, and it is our job to make them aware of it. It is our job to say no to our clients when they ask us for something we know is not going to work or that is not going to be done by a certain deadline. This is the same thing we would expect from a good lawyer, accountant, or doctor. We don’t tell these professionals what to do or how to do their jobs. They wouldn’t let us anyway. We go to these professionals with a problem (or a need) and we expect them to use their experience to explain which options we have and what their respective risks are. We expect them to give us enough information so that we can make informed decisions. But if we push them to do something that goes against what they think is right, they would simply say no. And that’s exactly what we should do.
Working software is not enough
In a software project, the most important deliverable is the software itself. And the quality of that code matters.
Rather than construction, programming is more like gardening.
- The Pragmatic Programmer
Like a garden, code needs constant maintenance.
If we don’t look after it constantly, the code starts to deteriorate as changes and new features are added. Bad design choices, lack of tests, and poor use of languages and tools will make the code rot faster.
When the code base gets into the situation where changes or additional features take too long to be implemented and developers are scared to touch the existing code, action must be taken immediately.
In order to increase business agility and have a good return on investment, keeping code quality high is paramount.
The biggest problem here is that bad code is invisible to everyone besides the developers. Other members of the team only realize that something is wrong when it is too late. That means it is the developers’ responsibility to look after the quality of the code.
Adding items to a technical debt backlog is a way that developers have to justify the bad code they’ve written without ever feeling guilty about it.
We don’t write bad code on purpose but we are constantly trying to find ways to justify it.
We as a developers often have a wrong notion of time.
We always think we are under pressure. We always feel we need to rush. Sometimes the pressure is put on us by the business, but more often than not, the pressure is self-imposed.
Pressure will always be part of a software developer’s life, and when we feel we are under pressure, we end up cutting corners. We don’t do that because we are sloppy. We normally do that because we feel that we need to go faster. We feel that we will be doing a good job if we provide the business with the features they want as fast as we can. We feel that meeting a promised deadline with a potentially buggy solution is better than being honest and transparent, and delivering a stable solution a few days later. Fast does not mean dirty and, unfortunately, we do not always understand the implications of our own decisions.
Attitude when working with legacy code
If a piece of software is expected to live and be maintained for more than a few weeks or months, neglecting its quality in order to go faster is an illusion. Many companies become hostages of their own software—their business agility (or lack of it) is totally related to how fast their software can be changed or improved. The worse the software quality is, the harder it will be to make changes to it. The longer it takes for a company to change or improve its software, the slower the company will be to react to changing market conditions.
Companies and developers need to understand that regularly taking the time to sharpen their saw is not a waste of time. In fact, it is the best way to save time and to keep moving fast.
The long road
We, software craftsmen, value and control our careers. We understand that a career is a life-long journey that, depending on the choices we make, may or may not lead us to mastery.
Think about your career as if you were managing a multiyear project. Once we understand the project vision—the ultimate goal—we take the most important requirements, break them down into smaller pieces, and iterate. While working on small iterations, we also keep reevaluating the project’s goals and adapting when necessary. It’s the same with our careers.
Create opportunities for other people to see how good we are.
Here are a few things we can do in order to create opportunities:
• Expand our technical knowledge, studying things that are out of our comfort zone, like new languages and technologies. • Attend user groups and technical community events. • Network with other developers and businesspeople. • Blog about the things we are learning and doing. • Contribute to open source projects. • Develop projects and make them publicly available. • Attend conferences. • Present at a conference.
The most important thing is to treat every single job as an investment, a step toward a bigger goal. Software craftsmen invest their ever-increasing knowledge, passion, time, dedication, and professional attitude in every job they have. Therefore, like any other type of investment, we need to be clear about what we expect as a return, and we need to measure it regularly throughout the length of that investment.
Knowledge is forever; money, stability, and security are not. If, for whatever reason, our job is terminated, knowledge and experience are the only things we will take with us. If we always focus on learning and becoming better software craftsmen, finding jobs that can provide us with a good income, stability, and security will always be a much simpler task than if we had spent our careers just focusing on getting more money.
There are three things that you should look for in each job:
- autonomy
- mastery
- purpose
In Drive: The Surprising Truth about What Motivates Us, Daniel Pink says that—assuming that money is off the table—knowledge workers are motivated by three things: autonomy, mastery, and purpose.
• Autonomy: It is when we are in control of what we do, how we do it, and when we do it. That should always be the case in a true Agile context.
• Mastery: It is when we are constantly learning and evolving—becoming better professionals and better human beings.
• Purpose: It is when we feel that our job is important and we are contributing to make things better—instead of just doing what we are told without understanding why.
The assumption of money being off the table is very important. When our basic needs are not satisfied, it is very difficult to focus and do our job well. The feeling of being underpaid always leaves a sour taste in our mouths. Even when we like the company we work for, we always end up questioning whether we are being unfairly treated.
People whose skills are obsolete worry about not finding another job where they can keep their salaries and personal life stability. More bluntly, only incompetent people are scared to lose their jobs. Software craftsmen are never scared to lose their jobs. For them, a career inside a company is only viable if it is aligned with their own career aspirations. Software craftsmen know that their careers are long roads, where the journey is far more important than reaching the end of the line.
Delivering value to clients is the obligation of any professional who is paid to do a job. But there is far more to a job than that. Work doesn’t need to be the antonym of pleasure—we just need to know what to look for when choosing a job: autonomy, mastery, and purpose. Those are the three things that a craftsman should look for in each job. Although it’s not always easy to find jobs that can provide us that, they exist. Maybe we are just not ready to get these jobs yet.
The better we are, the easier it is to find jobs that give us pleasure. But to reach a point where we can choose the jobs we want, we need a lot of focus and determination while developing our careers. We need to understand where we want to be and work hard to get there. A successful career doesn’t come for free. We need to craft it. Our own careers should always take precedence over a career inside a company. It’s great when a career inside a company is aligned with our own career aspirations but it is often a mistake to let a company control our careers. Jobs are an investment. Carefully choosing our jobs and satisfying all our clients is the best way to construct a very successful and pleasant career as a software craftsman.