--- product_id: 9532666 title: "The Clean Coder: A Code of Conduct for Professional Programmers" price: "€ 66.73" currency: EUR in_stock: true reviews_count: 13 url: https://www.desertcart.at/products/9532666-the-clean-coder-a-code-of-conduct-for-professional-programmers store_origin: AT region: Austria --- # The Clean Coder: A Code of Conduct for Professional Programmers **Price:** € 66.73 **Availability:** ✅ In Stock ## Quick Answers - **What is this?** The Clean Coder: A Code of Conduct for Professional Programmers - **How much does it cost?** € 66.73 with free shipping - **Is it available?** Yes, in stock and ready to ship - **Where can I buy it?** [www.desertcart.at](https://www.desertcart.at/products/9532666-the-clean-coder-a-code-of-conduct-for-professional-programmers) ## Best For - Customers looking for quality international products ## Why This Product - Free international shipping included - Worldwide delivery with tracking - 15-day hassle-free returns ## Description Programmers who endure and succeed amidst swirling uncertainty and nonstop pressure share a common attribute: They care deeply about the practice of creating software. They treat it as a craft. They are professionals. In The Clean Coder: A Code of Conduct for Professional Programmers, legendary software expert Robert C. Martin introduces the disciplines, techniques, tools, and practices of true software craftsmanship. This book is packed with practical advice–about everything from estimating and coding to refactoring and testing. It covers much more than technique: It is about attitude. Martin shows how to approach software development with honor, self-respect, and pride; work well and work clean; communicate and estimate faithfully; face difficult decisions with clarity and honesty; and understand that deep knowledge comes with a responsibility to act. Readers will learn What it means to behave as a true software craftsman How to deal with conflict, tight schedules, and unreasonable managers How to get into the flow of coding, and get past writer’s block How to handle unrelenting pressure and avoid burnout How to combine enduring attitudes with new development paradigms How to manage your time, and avoid blind alleys, marshes, bogs, and swamps How to foster environments where programmers and teams can thrive When to say “No”–and how to say it When to say “Yes”–and what yes really means Great software is something to marvel at: powerful, elegant, functional, a pleasure to work with as both a developer and as a user. Great software isn’t written by machines. It is written by professionals with an unshakable commitment to craftsmanship. The Clean Coder will help you become one of them–and earn the pride and fulfillment that they alone possess. Review: Must read for any programmer - Programming is an interesting profession. It’s not just an engineering exercise, where you’re building the most logical, structured, and well-designed application according to some set of industry best practices; rather, there’s a great deal of creativity that goes into it – an artistic quality, if you will. Instead of solving a particular problem the same way for every project, you must creatively adapt your thinking and communication to meet the expectations of each project’s stakeholders. Programming is not well understood like other professions. You know what lawyers, accountants, and doctors do. Their workflows and processes are well known since their professions are mature and a good portion of the population has interacted with them directly or indirectly. Programming, on the other hand, is different. To many people, a website or software solution magically just “appears” after a programmer spends time at his or her computer. Enter Robert C. Martin’s The Clean Coder. The Clean Coder helps demonstrate how programmers can conduct themselves as professionals, removing that black-box quality and holding themselves to standards as other professionals do so they garner the same respect from their peers and can help others do more with technology. I’ll talk about some of the lessons that really resonate with me: In the forward, Matthew Heusser relays a story about how his colleague, Joe, considers “estimates” from the technical team and “estimates” from the legal team with completely different mindsets. In short, Joe considered legal estimates to be final, whereas technical estimates were negotiable. Why weren’t estimates from the two teams treated equally? In my career, I’ve seen the same thing many times, largely stemming from three reasons. First is the assumed “magic” that non-technical people think programmers wield. Throughout the book, Martin explains how to remove the veil of mystery regarding said magic. Second is that I’ve run across others that compared us with their profession and made some assumptions, such as, though a harsher example, we’re being lazy or noncommittal. Here, the author discusses how to address such assumptions when confronted with them. Third, and the most important part that we can influence, is the tech person’s mindset and approach to work. From the text, the programmer learns how to craft their own mindset and workflows to handle these. In essence, we can’t make things perfect, but we control a lot of parameters to make things better. The first three chapters cover the conduct that a software developer professional should exhibit. A recurring theme within all three chapters is that software developers should take responsibility for what they say and do. Martin gracefully simplified this down to: how/why to say “no” and how/why to say “yes.” For example, if a developer agrees to a timeline, then they should make the timeline. If there are risks or unknowns on something you’re defining a timeline for, don’t agree to it, but rather just agree to what you can commit to if possible. The key is to not let yourself get bullied into agreeing to something you know you can’t meet with confidence. Others will build their own schedules and commitments around what you say, and there may be serious repercussions and loss of face if you fail to deliver. If you’re not as accurate as possible, you’ll erode the trust you have with your colleagues. Along with controlling and defining your commitments, you need to take responsibility for your work output. Specifically, being a professional means that you certify and guarantee that your work output functions. For example, accountants ensure that their accounts balance when they finish closing out the books monthly, quarterly, and year’s end. If they left discrepancies, they would soon find themselves out of work. However, developers seem to be able to deliver questionable code or features that just plain don’t work, again and again. I understand why: development is hard. There are a lot of moving pieces and people in a software development project; as a result, there are a lot of rules that get balanced when you go in and change something. None of that takes away from the fact that developers lose trust of their peers when they fail to deliver working solutions for the tasks assigned to them. They’ll probably remember the failure (their label, not yours) instead of the nuanced “whys” that caused that failure. Luckily, software developers have tools available to them to prevent this from happening, but only if the tools are actually put to use. Martin’s philosophy around testing is something with which I completely agree. The only way you can truly know that what you’ve added or changed doesn’t break everything else on a project – regardless of size – is to test it and have a structured, scalable approach to testing. Manual testing takes time, sometimes A LOT of time, and you leave a lot to chance that way. Hence automation. When automated, a test can be written once and then just be executed. It makes it trivial to repeatedly ensure that your code matches all the criteria it needs to meet. (Note: I wouldn’t recommend this approach across the board, particularly if an MVP, pilot system, or feature with a lot of changing specifications is being created, which is quite common with my startup customers. For something mature, scalable, and maintainable in a financially feasible manner, it’s required.) Martin’s discussion of “expected criteria” is another area that is really important for developers to understand and put to use. Ultimately, a customer or stakeholder will have to accept the software that a developer builds. When is the software done? What do clients judge the system’s success by? What aspects of the software do they value, and how do they prioritize what they value? To address this, I've always operated from the mindset of: the software is done when the customer tells me it's done. Part of that determination is working with the customer to define the acceptance criteria, though that can be difficult if the customer is non-technical or busy. Even high-level criteria are helpful, such as "Search for a product, and buy it” or “Load fast.” That’s fine so long as the stakeholders are open to iterations later to arrive at what they truly want. Conversely, the criteria could be very specific. Ideally, the developer helps the customer put more definition on their acceptance criteria throughout the process. The more quantitative, the better. The developer is finished with the work when they deploy or deliver the software or functionality that meets all the acceptance criteria. In conclusion, it’s not so important how the acceptance tests are written even though there are best practices; what is important is that you and the client know what is “done” and agree to it. The book is chock-full of other applicable advice as well, from numerically-driven ways to handle estimates to suggestions for interacting with colleagues. All of the recommendations align to the goal of helping developers comport themselves as professionals so they’ll be treated as such by other professionals. It’s very important because our work is nebulous and our profession is new. I highly recommend this book to anyone who wants to be a professional software developer for the long-term or works a lot with them. Review: Not what I'd thought it would be. - I thought this would be about details of a type of coding or coding practice. I can't say I enjoyed the book but I learned a great deal from it. This book deals with the philosophy and ethics of being professional first, and being a coder second. It brought home a lot of flaws that I've displayed across the years. That's why it wasn't all that enjoyable; the writing was all too clear and direct. Although I've been around IT for some time, I've only recently started working directly with professonal developers. That was my motivation for buying the book -- so I could do a better job and maybe earn a bit of respect. It did introduce me to Test Driven Developement (that in itself ought to reinforce that professional coding is new to me). After just one day of trying it I find that I pick up after distractions much faster, cover more cases to test, and even write in such a way the code seems to document itself without the huge effort I've had to make in the past just to get so-so results. And it seems to make even some of the dreary parts more fun because you can almost imagine it as a game you play against yourself. So I'm sold on TDD. I'd begun to realize the importance of having good estimates and honest, timely reappraisals before starting to read the book, but the author certainly drives home how very critical this is to a professional coder and the rest of the team. If you've programmed essentially for yourself (as a systems admin or database admin) but are moving toward true development, this is an essential book to read. It will show you bad habits to avoid and drive home the professional behavior that will earn you respect. I admit that is based on only about three months of experience in working with developers, but over the past two weeks (since I started the book) I'm sure that I sense a greater acceptance and respect. ## Technical Specifications | Specification | Value | |---------------|-------| | Best Sellers Rank | #136,673 in Books ( See Top 100 in Books ) #18 in Software Design & Engineering #29 in Microsoft Programming (Books) #64 in Software Development (Books) | | Customer Reviews | 4.6 out of 5 stars 2,276 Reviews | ## Images ![The Clean Coder: A Code of Conduct for Professional Programmers - Image 1](https://m.media-amazon.com/images/I/81L+johQmlL.jpg) ## Customer Reviews ### ⭐⭐⭐⭐⭐ Must read for any programmer *by P***N on April 15, 2016* Programming is an interesting profession. It’s not just an engineering exercise, where you’re building the most logical, structured, and well-designed application according to some set of industry best practices; rather, there’s a great deal of creativity that goes into it – an artistic quality, if you will. Instead of solving a particular problem the same way for every project, you must creatively adapt your thinking and communication to meet the expectations of each project’s stakeholders. Programming is not well understood like other professions. You know what lawyers, accountants, and doctors do. Their workflows and processes are well known since their professions are mature and a good portion of the population has interacted with them directly or indirectly. Programming, on the other hand, is different. To many people, a website or software solution magically just “appears” after a programmer spends time at his or her computer. Enter Robert C. Martin’s The Clean Coder. The Clean Coder helps demonstrate how programmers can conduct themselves as professionals, removing that black-box quality and holding themselves to standards as other professionals do so they garner the same respect from their peers and can help others do more with technology. I’ll talk about some of the lessons that really resonate with me: In the forward, Matthew Heusser relays a story about how his colleague, Joe, considers “estimates” from the technical team and “estimates” from the legal team with completely different mindsets. In short, Joe considered legal estimates to be final, whereas technical estimates were negotiable. Why weren’t estimates from the two teams treated equally? In my career, I’ve seen the same thing many times, largely stemming from three reasons. First is the assumed “magic” that non-technical people think programmers wield. Throughout the book, Martin explains how to remove the veil of mystery regarding said magic. Second is that I’ve run across others that compared us with their profession and made some assumptions, such as, though a harsher example, we’re being lazy or noncommittal. Here, the author discusses how to address such assumptions when confronted with them. Third, and the most important part that we can influence, is the tech person’s mindset and approach to work. From the text, the programmer learns how to craft their own mindset and workflows to handle these. In essence, we can’t make things perfect, but we control a lot of parameters to make things better. The first three chapters cover the conduct that a software developer professional should exhibit. A recurring theme within all three chapters is that software developers should take responsibility for what they say and do. Martin gracefully simplified this down to: how/why to say “no” and how/why to say “yes.” For example, if a developer agrees to a timeline, then they should make the timeline. If there are risks or unknowns on something you’re defining a timeline for, don’t agree to it, but rather just agree to what you can commit to if possible. The key is to not let yourself get bullied into agreeing to something you know you can’t meet with confidence. Others will build their own schedules and commitments around what you say, and there may be serious repercussions and loss of face if you fail to deliver. If you’re not as accurate as possible, you’ll erode the trust you have with your colleagues. Along with controlling and defining your commitments, you need to take responsibility for your work output. Specifically, being a professional means that you certify and guarantee that your work output functions. For example, accountants ensure that their accounts balance when they finish closing out the books monthly, quarterly, and year’s end. If they left discrepancies, they would soon find themselves out of work. However, developers seem to be able to deliver questionable code or features that just plain don’t work, again and again. I understand why: development is hard. There are a lot of moving pieces and people in a software development project; as a result, there are a lot of rules that get balanced when you go in and change something. None of that takes away from the fact that developers lose trust of their peers when they fail to deliver working solutions for the tasks assigned to them. They’ll probably remember the failure (their label, not yours) instead of the nuanced “whys” that caused that failure. Luckily, software developers have tools available to them to prevent this from happening, but only if the tools are actually put to use. Martin’s philosophy around testing is something with which I completely agree. The only way you can truly know that what you’ve added or changed doesn’t break everything else on a project – regardless of size – is to test it and have a structured, scalable approach to testing. Manual testing takes time, sometimes A LOT of time, and you leave a lot to chance that way. Hence automation. When automated, a test can be written once and then just be executed. It makes it trivial to repeatedly ensure that your code matches all the criteria it needs to meet. (Note: I wouldn’t recommend this approach across the board, particularly if an MVP, pilot system, or feature with a lot of changing specifications is being created, which is quite common with my startup customers. For something mature, scalable, and maintainable in a financially feasible manner, it’s required.) Martin’s discussion of “expected criteria” is another area that is really important for developers to understand and put to use. Ultimately, a customer or stakeholder will have to accept the software that a developer builds. When is the software done? What do clients judge the system’s success by? What aspects of the software do they value, and how do they prioritize what they value? To address this, I've always operated from the mindset of: the software is done when the customer tells me it's done. Part of that determination is working with the customer to define the acceptance criteria, though that can be difficult if the customer is non-technical or busy. Even high-level criteria are helpful, such as "Search for a product, and buy it” or “Load fast.” That’s fine so long as the stakeholders are open to iterations later to arrive at what they truly want. Conversely, the criteria could be very specific. Ideally, the developer helps the customer put more definition on their acceptance criteria throughout the process. The more quantitative, the better. The developer is finished with the work when they deploy or deliver the software or functionality that meets all the acceptance criteria. In conclusion, it’s not so important how the acceptance tests are written even though there are best practices; what is important is that you and the client know what is “done” and agree to it. The book is chock-full of other applicable advice as well, from numerically-driven ways to handle estimates to suggestions for interacting with colleagues. All of the recommendations align to the goal of helping developers comport themselves as professionals so they’ll be treated as such by other professionals. It’s very important because our work is nebulous and our profession is new. I highly recommend this book to anyone who wants to be a professional software developer for the long-term or works a lot with them. ### ⭐⭐⭐⭐⭐ Not what I'd thought it would be. *by T***E on August 8, 2014* I thought this would be about details of a type of coding or coding practice. I can't say I enjoyed the book but I learned a great deal from it. This book deals with the philosophy and ethics of being professional first, and being a coder second. It brought home a lot of flaws that I've displayed across the years. That's why it wasn't all that enjoyable; the writing was all too clear and direct. Although I've been around IT for some time, I've only recently started working directly with professonal developers. That was my motivation for buying the book -- so I could do a better job and maybe earn a bit of respect. It did introduce me to Test Driven Developement (that in itself ought to reinforce that professional coding is new to me). After just one day of trying it I find that I pick up after distractions much faster, cover more cases to test, and even write in such a way the code seems to document itself without the huge effort I've had to make in the past just to get so-so results. And it seems to make even some of the dreary parts more fun because you can almost imagine it as a game you play against yourself. So I'm sold on TDD. I'd begun to realize the importance of having good estimates and honest, timely reappraisals before starting to read the book, but the author certainly drives home how very critical this is to a professional coder and the rest of the team. If you've programmed essentially for yourself (as a systems admin or database admin) but are moving toward true development, this is an essential book to read. It will show you bad habits to avoid and drive home the professional behavior that will earn you respect. I admit that is based on only about three months of experience in working with developers, but over the past two weeks (since I started the book) I'm sure that I sense a greater acceptance and respect. ### ⭐⭐⭐⭐ Professionalism as defined by Bob Martin *by B***E on September 23, 2011* The clean coder is sort-of a follow-up on Clean Code. Where Clean Code explained how the code of a professional developer should look like, the Clean Coder explains what it takes for a developer to consider themselves a professional. The book is fairly small (200 pages) and it is an easy and quick read. The chapters are small and coverage is broad (and thus narrow at times...) The book consists of of 14 chapters. Each chapter covers an aspect of software development and describes Bob's opinion on what it means to be a professional in that particular aspect. The first chapter is an overview. Chapter 2 and 3 talk about the ability to say NO! and not being pressured or talked into unrealistic promises and about how serious you ought to take it if you do say yes. Chapter 4-8 discuss development-focused practices, from coding (4), to test-driving (5), practicing your skills (6), working with the customer by acceptance testing (7) and different strategies for testing (8). Each of the chapters is short that it doesn't really talk about the concepts, but it points out some important parts and explains why it is important for professionals to act a certain way. Chapter 9-11 are more time-practices. Starting from Time Management (9), Estimation (10) and dealing with pressure (11). These chapters also strongly relate to the "Saying No" chapter (2) of not making unrealistic commitments and the "Saying Yes" (3) chapter of letting "Yes!" actually mean something. Especially the pressure chapter is one that the reader probably ought to read several times :) Chapter 12-13 discuss about professionals working together with other people, with customers and with other developers. Chapter 13 is a little off as it covers a bit more on organizational structure to make efficient teams than how to act as a professional developer. Chapter 14, the ending chapter, covers mentoring and craftsmanship. It stresses (a topic Bob often repeats) how silly it is that even McDonalds employees are better mentored in their job than an average SW developer. It envisions a better way of growing great developers in organizations. The Clean Coder is an important book as there aren't many book on the topic of behavior of individual developers. Especially the topics related to developer behavior under pressure and making and avoiding commitments are, in my experience, of most importance for good software development... yet rarely discussed. The book is an important book, yet I felt disappointed at times. Most topics are covered really shallow (keeping the book small) and at times it felt Bob was just cherry-picking a couple of practices he felt important. Also, at times, I felt the book was inconsistent with itself. For example, one of the things that annoyed me, is that in Chapter 1 he talks about professionalism and how one aspect of professionalism is to "know your field". Yet, in the chapter of professionalism he doesn't at all refer back to earlier attempts on the same subject. He doesn't refer to After the Gold Rush: Creating a True Profession of Software Engineering (DV-Best Practices) or about the attempts of IEEE and ACM of defining our profession. If you are writing on the subject, and tell people they should "know the field" then at least you ought to refer back to the earlier developments in "the field". Similarly, I felt the book is seriously lacking references to further study on the important practices that are covered. The Clean Coder is also a very personal book. Bob is obviously the Clean Coder in the title and the definition of professionalism is his definition of being a professional. The book is full of stories from Bob's long career that helped him reach these conclusions... what it means to be a professional. I enjoyed the stories from his career a lot and it makes the book at times, almost an autobiography... Conclusion. At times, I though this is definitively a 5 star book, yet at times I felt it is just average and shallow and doesn't deserve more than 3 stars. In the end, for me, it was the topic of unrealistic commitment that forms the skeleton of the book that I decided on 4 stars. It is less good as his earlier 2 books Clean Code: A Handbook of Agile Software Craftsmanship and Agile Software Development, Principles, Patterns, and Practices . But it is definitively an important book and worth reading, especially when you want to help building a true profession. ## Frequently Bought Together - The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series) - Clean Code: A Handbook of Agile Software Craftsmanship - Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) --- ## Why Shop on Desertcart? - 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016 - 🌍 **Shop Globally** — Access 737+ million products across 21 categories - 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price - 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members) - 🔒 **Secure Payments** — Trusted payment options with buyer protection - ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews **Shop now:** [https://www.desertcart.at/products/9532666-the-clean-coder-a-code-of-conduct-for-professional-programmers](https://www.desertcart.at/products/9532666-the-clean-coder-a-code-of-conduct-for-professional-programmers) --- *Product available on Desertcart Austria* *Store origin: AT* *Last updated: 2026-05-30*