The Software Craftsman Kitabından Aldığım Notlar - 2

1.bölümün devamı :

A BETTER METAPHOR

We can say that Software Craftsmanship is a better metaphor for software development than software engineering. Software Craftsmanship sees software as a craft and compares software developers to medieval blacksmiths.

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 talks about: caring about what they do; always trying to better themselves; being professional; delighting customers by helping them achieve whatever they want to achieve; learning from other developers; sharing what they know; and mentoring less-experienced developers.

Well-crafted software means that, regardless of how old the application is, developers can understand it easily. The side effects are well known and controlled. It has high and reliable test coverage, clear and simple design, and business language well expressed in the code. Adding or changing features does not take longer than it used to take at the beginning of the project, when the code base was small.

The code must be maintainable and predictable. Developers must know what is going to happen when changing the code and must not be afraid to change it. Changes should be localized and not affect other parts of the application—no ripple effects. In a few minutes, if not seconds, after pressing a button, tests will check the entire application and inform you if there is something broken.

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.

BOY SCOT RULE

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.

Sharing and mentoring are at the heart of Software Craftsmanship. Software craftsmen are passionate and always strive to better themselves. However, we have a far bigger mission: we are responsible for preparing the next generation of craftsmen.

Software craftsmen are not factory workers. We want to actively contribute to the success of the project, questioning requirements, understanding the business, proposing improvements, and productively partnering with our customers or employers. This is a different approach to the traditional employer/employee model and the advantages for the employers are enormous.

The Software Craftsmanship 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.

Sharing our knowledge with less-experienced software craftsmen is our moral obligation.

If developers want to be treated as professionals, they should start acting as professionals. A software professional must, among other things, get involved and contribute to the business, provide options and solutions, and offer the best service when it comes to the implementation, technologies, and quality of what we produce.

KEEPING OURSELVES UP TO DATE

• Books, many books

• Blogs

• Technical websites

• Know who to follow

• Learn how to use twitter. Used wisely, Twitter can be a great tool for information gathering.

• Practice, practice, practice

• Katas

• Pet projects

• Open source

• Pair programming

• Socialize

DELIBERATE DISCOVERY

The biggest mistake that software professionals can make is not accepting that they don’t know what they don’t know. Not knowing what we don’t know is also called second-level ignorance. Accepting that we have a lot to learn is a sign of maturity and one of the first steps toward mastery.

Go to bed 30 minutes earlier than normal and use this time to read a book, look at blogs, or watch technical screencasts before falling asleep.

ENLIGHTENED MANAGERS

Good managers understand that they are part of the team and need to work with the developers toward the common goal. There is no “us and them” attitude.

Managers should appreciate when we say we cannot deliver some features.

Transparency helps managers and the team to prepare for tough situations. Raising the red flag as early as possible, indicating that something is wrong, allows the team and all people involved to be pragmatic and come up with alternative solutions.

Good managers are part of the team. They stay with the team during good and bad times. If everyone is committed to work extra hours, they should be there as well, even if just to buy the pizzas, give moral support, and crack a few jokes every now and again. The team feels better knowing that everyone is in the same boat, feeling the same pain or enjoying success.

LOOKING AFTER OUR GARDEN

Code is organic, not mechanical. Like a garden, code needs constant maintenance.

If we want things to be better, we need to do something about it.

XP PRACTICES AND VALUES

Test first helps us to think out our ideas; to focus on a single thing at a time; to be precise when defining the responsibility of modules, classes, and functions; and to work in small increments. It gives us assurance our code works according to our expectations. Since each test takes from a few milliseconds (unit tests) to a few seconds (higher-level tests) to run, test first gives us very quick feedback loops when writing the production code. Writing tests first helps us to just write enough code to satisfy the requirements, keeping the code simple. It reduces complexity and overengineering. That’s the value it brings to the business.

Complexity in our code and bad design choices are highlighted by the complexity in maintaining and writing new tests. These tests lead us to re-analyze the design of our code and refactor to make it simpler.

PRAGMATISM

Being pragmatic is one of the best qualities that a software craftsman can have. We should not follow practices just because someone said so, or just for the sake of it. We should constantly look for ways of doing our job better and satisfying our customers. If that means using TDD, we should use TDD. Whenever we find something else that could give us more value and a quicker feedback loop, then we should use that thing instead of TDD.

The best way to know if one practice is better than the other is to compare the value they both bring to the project, then compare how long their feedback loops are.

If we can’t identify the value that different practices give us, maybe we should not use them.

The Long Road

Are we really looking after our careers? Do we really know where we are going or where we want to be? What are the things that really motivate us to do a great job? Should we see our jobs as an investment? If yes, what should be the return on our investment?

I realized that I had to move out of my comfort zone, take ownership of my career, and constantly look for opportunities where I could learn and improve. It was my life, my career, and I should own it.

We need to make people feel comfortable to come and speak to us.

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 things described above may create situations where we can receive options that we were not considering before, and this could help us decide what to do next.

When it comes to our career, there is no right or wrong. But there is something worth keeping in mind: 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.

---

- Sandro Mancuso