Buy New
-9%
$27.32$27.32
FREE delivery Monday, April 27 on orders shipped by Amazon over $35
Ships from: Amazon Sold by: Abide Bookstore
Used - Like New
$7.83$7.83
FREE delivery April 30 - May 4
Ships from: ThriftBooks-Dallas Sold by: ThriftBooks-Dallas
Sorry, there was a problem.
There was an error retrieving your Wish Lists. Please try again.Sorry, there was a problem.
List unavailable.
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
Software Craftsmanship: The New Imperative 1st Edition
Purchase options and add-ons
Software Craftsmanship is a call to arms for programmers: an impassioned manifesto that restores the developer to a central role in large-scale projects, and shows developers how to master the skills they need to succeed in that role. Software Craftsmanship transcends "software engineering," demonstrating that quality software can't simply be "manufactured": it must be built by craftspeople with pride in their work, and a personal commitment to excellence. In Software Craftsmanship, Pete McBreen focuses on the craft of software development, explaining why current "software engineering" techniques often fail, and offering programmers a new path to excellence. Just as the modern carpenter benefits from better tools, materials, and understanding, the modern programmer can benefit from better computers, reusable components, and more robust languages -- but only if he or she is prepared to treat the software profession as a true "craft." McBreen explains what software "craftsmanship" means, how its affects users, and how it changes the developer's relationship with customers. He introduces the concepts of software apprentices and journeymen, shows what can (and can't) be learned from the software engineering movement, and presents specific steps you can take now to move towards craftsmanship in your work -- and your organization.
- ISBN-100201733862
- ISBN-13978-0201733860
- Edition1st
- PublisherAddison-Wesley Professional
- Publication dateAugust 23, 2001
- LanguageEnglish
- Dimensions0.5 x 7.3 x 9 inches
- Print length208 pages
Frequently bought together

Similar items that may deliver to you quickly
Clean Code: A Handbook of Agile Software CraftsmanshipPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Monday, Apr 27
Crafting Excellence: The Art & Science of Modern Software QualityTravis A. ColemanPaperbackFREE Shipping by AmazonGet it as soon as Monday, Apr 27
Agile Technical Practices Distilled: A learning journey in technical practices and principles of software designPedro M. SantosPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Monday, Apr 27
Practices of an Agile Developer: Working in the Real World (Pragmatic Bookshelf)PaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Monday, Apr 27Only 2 left in stock (more on the way).
Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)PaperbackFREE Shipping by AmazonGet it as soon as Monday, Apr 27
Modern Software Engineering: Doing What Works to Build Better Software FasterPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Monday, Apr 27
Customers also bought or read
- The Pragmatic Programmer: Your Journey To Mastery, 20th Anniversary Edition (2nd Edition)#1 Best SellerSoftware Design & Engineering
Hardcover$41.64$41.64FREE delivery Mon, Apr 27 - Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
Paperback$27.63$27.63Delivery Apr 30 - May 1 - Software Craftsman, The: Professionalism, Pragmatism, Pride (Robert C. Martin Series)
Paperback$38.40$38.40FREE delivery Mon, Apr 27 - UML Distilled: A Brief Guide to the Standard Object Modeling Language (Addison-Wesley Object Technology Series)
Paperback$21.41$21.41Delivery Mon, Apr 27 - Design Patterns: Elements of Reusable Object-Oriented Software#1 Best SellerObject-Oriented Design
Hardcover$33.61$33.61Delivery Mon, Apr 27 - Working Effectively with Legacy Code (Robert C. Martin Series)
Paperback$53.46$53.46FREE delivery Mon, Apr 27 - Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)
Paperback$38.37$38.37FREE delivery Mon, Apr 27
Editorial Reviews
From the Back Cover
By recognizing that software development is not a mechanical task, you can create better applications.
Today’s software development projects are often based on the traditional software engineering model, which was created to develop large-scale defense projects. Projects that use this antiquated industrial model tend to take longer, promise more, and deliver less.
As the demand for software has exploded, the software engineering establishment has attempted to adapt to the changing times with short training programs that teach the syntax of coding languages. But writing code is no longer the hard part of development; the hard part is figuring out what to write. This kind of know-how demands a skilled craftsman, not someone who knows only how to pass a certification course.
Software Craftsmanship presents an alternative―a craft model that focuses on the people involved in commercial software development. This book illustrates that it is imperative to turn from the technology-for-its-own-sake model to one that is grounded in delivering value to customers. The author, Pete McBreen, presents a method to nurture mastery in the programmer, develop creative collaboration in small developer teams, and enhance communications with the customer. The end result―skilled developers who can create, extend, and enhance robust applications.
This book addresses the following topics, among others:
- Understanding customer requirements
- Identifying when a project may go off track
- Selecting software craftsmen for a particular project
- Designing goals for application development
- Managing software craftsmen
Software Craftsmanship is written for programmers who want to become exceptional at their craft and for the project manager who wants to hire them.
0201733862B07242001
About the Author
Pete McBreen is an independent consultant who actually enjoys writing and delivering software. Despite spending a lot of time writing, teaching, and mentoring, he goes out of his way to ensure that he does hands-on coding on a live project every year. Pete specializes in finding creative solutions to the problems that software developers face. After many years of working on formal and informal process improvement initiatives, he took a sideways look at the problem and realized, “Software development is meant to be fun. If it isn’t, the process is wrong.” Pete lives in Cochrane, Alberta, Canada and has no plans to move back to a big city.
0201733862AB07092002
Excerpt. © Reprinted by permission. All rights reserved.
Craftsmanship is a return to the roots of software development: Good software developers have always understood that programming is a craft skill. Regardless of the amount of arcane and detailed technical knowledge that a person has, in the end, application development comes down to feel and experience. Someone can know all of the esoteric technical details of the Java programming language, but that person will never be able to master application development unless he or she develops a feel for the aesthetics of software. Conversely, once a person gets the feel for software development, the specific technical details become almost irrelevant. Great developers are always picking up and using new technology and techniques; learning a new technology is just a normal part of the life of a software developer.
The term software engineering was coined in 1967 by a NATO study group that recommended a conference to discuss “the problems of software.” The report from this 1968 conference, which was sponsored by the NATO Science Committee and took place in Garmish, Germany, was titled Software Engineering.1 In the report, Peter Naur and Brian Randell stated, “The phrase ‘software engineering’ was deliberately chosen to be provocative, in implying the need for software manufacture to be based on the types of theoretical foundations and practical disciplines that are traditional in the established branches of engineering.”
In the same spirit, it is the intention of this book to be deliberately provocative in implying the need for practitioners to start paying attention to the craft of software development. Software craftsmanship is important because it takes us away from the manufacturing metaphor that software engineering invokes and makes us pay attention to the people who do software development. Craftsmanship brings with it the metaphor of skilled practitioners intent on mastering their craft, of pride in and responsibility for, the fruits of their labor.
Software craftsmanship is not the opposite of software engineering or computer science. Rather, craftsmanship is a different tradition that happily coexists with and benefits from science and engineering. Just as the modern blacksmith benefits from better tools, materials, and understanding, so software craftsmanship benefits from better computers, reusable components, and programming languages. Just as blacksmiths transcend science and engineering with their skill and artistry, software craftsmanship can transcend computer science and software engineering to produce great programs, applications, and systems. UNIX and the modern-day GNU Linux are probably the best-known examples of this—systems that are thriving due to the craft, skill, and dedication of their creators.
Software craftsmanship is a response to the problems of trying to force-fit software engineering into commercial application development. Software engineering was developed to meet the needs of NATO in developing very large defense systems. Commercial application development differs from the development of defense and government systems in that applications are a whole lot smaller and normally have to be up and running in less than 18 months. It is rare for a commercial application to be developed by a team of more than 20 people, and most application developers work in teams with fewer than 10 members. Software engineering is good at handling the problems of really large teams of 200 or more people, but it has little to say about how the individuals in a team should practice their craft.
Software engineering encourages the “human wave” 2 approach to software development. Rather than solving the problem of how to develop highly skilled developers, software engineering attempts to deskill software development by suggesting that every problem can be solved by throwing more people at it.
Although this approach sometimes succeeds, the resulting software is junk. Slow and bloated, it just never feels right. Users are dazzled by the graphics and animation but never really manage to come to grips with the software. They are thwarted by their inability to learn the software and use only a small fraction of the available features.
Software does not have to be like that. All too often I see application development teams shipping valuable applications that provide real, measurable business benefit, but apologizing for not following software engineering best practices. For me, the real test of a team is whether it manages to ship and then enhance and extend the application for years afterward. Timely shipping of the first release is important, but it is more important that subsequent releases occur in a timely fashion and that each new release improves the application.
Whenever I’m asked about hiring developers, I tell people to look for developers who have shipped a few applications successfully and then stuck around long enough to handle the next enhancement or maintenance release. Shipping proves that the developer can make something work; staying around for the next release allows the developer to experience the effects of the way that he or she built the application in the first place. If a developer has done this three times, my guess is that he or she is skilled and experienced enough in the craft of software development to be successful again.
Software craftsmanship is the new imperative because many members of the software development community are starting to chase technology for its own sake, forgetting what is important. The purpose of software development is to create high-quality, robust software applications that deliver value to their users. What matters is growing a new generation of developers who can do that.
Software craftsmanship stands for putting the joy and excitement back into creating applications for our users.
1 Naur, Peter, and Brian Randell, (eds.), Software Engineering: A Report on a Conference Spnsored by the NATO Science Committee,NATO, 1969.
2 Levy, Steven, Hackers, Penguin Books, 1994, p. 88. 0201733862P08202001
Product details
- Publisher : Addison-Wesley Professional
- Publication date : August 23, 2001
- Edition : 1st
- Language : English
- Print length : 208 pages
- ISBN-10 : 0201733862
- ISBN-13 : 978-0201733860
- Item Weight : 15.2 ounces
- Dimensions : 0.5 x 7.3 x 9 inches
- Best Sellers Rank: #645,797 in Books (See Top 100 in Books)
- #142 in Software Design & Engineering
- #594 in Software Development (Books)
- #1,579 in Computer Software (Books)
- Customer Reviews:
About the author

Discover more of the author’s books, see similar authors, read book recommendations and more.
Related products with free delivery on eligible orders
Customer reviews
- 5 star4 star3 star2 star1 star5 star85%8%7%0%0%85%
- 5 star4 star3 star2 star1 star4 star85%8%7%0%0%8%
- 5 star4 star3 star2 star1 star3 star85%8%7%0%0%7%
- 5 star4 star3 star2 star1 star2 star85%8%7%0%0%0%
- 5 star4 star3 star2 star1 star1 star85%8%7%0%0%0%
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonTop reviews from the United States
There was a problem filtering reviews. Please reload the page.
- Reviewed in the United States on November 5, 2005Format: PaperbackVerified PurchaseAn excellent comparison of software engineering and software craftsmanship. Pete McBreen clearly illustrates the the traits of software craftsmanship and details the steps required to go from apprentice to journeymen and possibly to master craftsmen if desired. After reading this book, you'll begin to appreciate the finer skills of software development along with the knowledge of knowing when the "classical" software engineering approach is more appropriate. The concepts covered include: achieving quality, selecting a team, mentoring others, requirements, maintenance / extensibility, and estimation / scheduling.
If you are looking for directions on how to become one of the software programing elite, this is the map. This book is also an excellent guide for those trying to staff software projects with quality talent in that you'll know who the true craftsmen really are. Perfectly edited, filled with solid references, clear examples, and easily readable text.
- Reviewed in the United States on July 13, 2016Format: PaperbackVerified Purchasethis is a real nice read
- Reviewed in the United States on June 3, 2004Format: PaperbackThe book starts by making several good observations:
(1) Software Engineering, with it's focus on big-up-front design, is not working well in the business world.
(2) Emergent Design and Iterative Development actually work for business systems.
(3) An apprentice/journeyman/master system relying on communication and OJT will be more effective than a BS in CS and a one-week course in SQL.
(4) The focus on buzzwords and bleeding edge technologies is actually harmful to our craft.
(5) The idea that learning is somehow bad because it implies the learner doesn't know everything is bogus and wrong. In fact, the idea that there is a single 'right way to do it' is equally bogus. We should instead grow developers with a wide knowledge of different techniques and allow them to find the right technique for each project.
(6) The mobility and job-hopping of developers is counter-productive to effectiveness. People are not cogs. Therefore ...
(7) Developers who are widely successfull and stay at a company long enough be of real value should be highly compensated; the author suggests up to $250,000/year and that super-stars should be paid higher than the managers (and possibly executives) who they report to. Without this, ambitious developers are forced into becoming consultants, trainers, or managers.
---> That said, there were a few things that make this book less-than-five-stars:
(1) The work isn't really 'new.' The book is a neat combination of the work of Deming, DeMarco, Dave Thomas (The pragmatic programmer, not the Wendy's CEO), and the XP/Agile Crowd. A lot of the book is Deming applied to software, but readable and enjoyable.
(2) While some of the book is clearly ideas the author does consistently and knows work, some of it seems to be neat theoretical stuff that hasn't been tried. The thing that hit me was the ideas that developers should make $250,000 per year or they will be 'forced' into consulting ... the author is a consultant. How to even make it possible to create an environment where the developer makes more than his boss is worthy of a chapter or two, but it is not covered in depth, and I get the feeling that is because the author has never actually seen it in real life.
In short, if you have tried traditional charts and diagrams and design documents and big-test-plan 'Software Engineering' and you think 'there has got to be a better way' - try this book. If you are a big agile/XP/Scrum person looking for a book to give away to friends, this might be the one. If you are allready convinced and want more deep, practical guidance, you are probably better off going to the sources: Deming, DeMarco, Jeffries, Beck, Cunningham, Brooks, etc.
- Reviewed in the United States on March 5, 2008Format: PaperbackI'll begin with a couple of quotes from the book which will set up the frame of further discussion.
---QUOTE---
In the [NATO 1969] report Peter Naur and Brian Randell stated "The phrase 'software engineering' was deliberately chosen to be provocative, in implying the need for software manufacture to be based on the types of theoretical foundations and practical disciplines that are traditional in the established branches of engineering."
...
In the same spirit, it is the intention of this book to be deliberately provocative in implying the need for practitioners to start paying attention to the craft of software development. Software craftsmanship is important because it takes us away from the manufacturing metaphor that software engineering invokes and makes us pay attention to the people who do software development.
...
This book is a call to arms: We must insist that developers really know their craft before we trust them to create systems for us or with us.
---/QUOTE---
Like some other books on the topic, this one is about the importance of the actual people who do the development. But this one is special in that it argues that the traditional approach to software development - exactly the "software engineering" has a viable alternative - the "software craftsmanship". Not only it suggests that good team is important, it goes further explaining how groups and individuals should be working differently.
The author draws a rather arbitrary line of 100 man/years of development and suggests that any project less than that would benefit from following software craftsmanship. Software craftsmanship thus does not deny the software engineering, but limits its niche to huge military projects and alike where a horde of average programmers work to rule.
Compared to that, software craftsmanship is a perpetual development of the team and each of its members while producing a high quality applications of typical size. In other words, both software engineering and software craftsmanship are ways of developing software, but whereas the former is about projects, the latter is about projects AND PEOPLE.
---QUOTE---
A key problem with the software engineering mindset is that programmers can be misled into thinking that they know everything there is to know about a subject. Software development does not work like that.
...
With software craftsmanship, the intention is to get the best possible tools into the hands of capable developers so that small teams can create applications that once required the services of the lots of people.
---/QUOTE---
One other aspect, just as important is that software craftsmanship is not only about the team dynamics. It also suggests the healthy long-term relationships between the developers and the customers where customers *gasp* actually work to help the developers build the application for them.
---QUOTE---
Overall, because developers who adopt the software craftsmanship approach accept responsibility for the applications they create, customers benefit from the long term relationship that this implies. A long-term relationship with developers is crucial because the best person to maintain an application is the person who developed it.
...
Software craftsmanship gives customers what they need - namely, stable, long-lived applications rather than old-style legacy applications that cause significant disruption and trauma every few years when they have to be replaced.
---/QUOTE---
My guess is that most of the developers that perform actual active development would support the idea. At the same time the common managerial practice, the belief in "one true way", "best practice" and "big M methodology" would prevent it from cutting to the core of many organizations. Well, too bad. Pete McBreen, you have grassroots support, that's for sure !
Developer, or manager alike, do read the book. It will give you a different perspective and hopefully will push you to action.
This book feels like an essay rather than "a book on software development". The language is free and relaxed, and there are practically no technical references or examples. The citations from other sources found in this book are often more concise, clear and to the point than the surrounding discussion.
As far as call to arms is concerned, the book outlines the attack direction, but does not give any ground for it. Take this book to the heart (like I did), you will still to engage in countless fights and arguments over ways of doing things.
Great book, a grassroots movement manifesto for better software development.
Top reviews from other countries
-
José Ramón Romero ChávezReviewed in Mexico on June 24, 20194.0 out of 5 stars Buen Libro
Format: PaperbackVerified PurchaseBuen libro muchas ideas pero es demasiado corto
-
Sir BebeReviewed in Germany on April 8, 20245.0 out of 5 stars Über sich selbst nachdenken, was man so macht, jeden Tag
Format: PaperbackVerified PurchaseKlasse Buch, liest sich super leicht und trifft den Nagel ständig auf den Kopf, auch wenn man immer wieder versucht ist "ja, aber..." zu sagen. Es regt einfach dazu an, Softwareentwicklung morgen besser machen zu wollen. Wenn man handgemachte Software liebt und/oder damit sein Geld verdient, ein absolutes Muss. Ich hab für mich viel rausgenommen, auch wenn es hart wird, dass auch umzusetzen. Aber wer fragt schon nach leicht...
SohneeReviewed in the United Kingdom on November 27, 20115.0 out of 5 stars The New Imperative
Format: PaperbackVerified PurchaseThis book is very well researched and contains references to myriad books and studies to back up what is being said.
The essence of the Software Craftsmanship model is to stop trying to control a large number of average developers and instead employ exceptional developers who can self-organise. There is plenty of advice on how to organise a team around a master-craftsman and how to give the novice developers the path to becoming journeymen and eventually master craftsmen.
Anyone who has worked in companies with lots of warm bodies who cannot reliably get quality software shipped will understand why there is a need to change our attitude towards software development. This book is only controversial if you rely on the hierarchy of software engineering or want to sell certifications.
C4sp3rl3Reviewed in Germany on February 19, 20175.0 out of 5 stars I have never ever laugh such much while reading a book about Software Engineering
Format: PaperbackVerified PurchaseThis is a great book about Software Engineering which brings in a totally different view. It is written in a very entertaining form and for me it was cool to read!








