Software Craftsmanship: The New Imperative [Paperback]

Pete McBreen (Author)

Book Description

Publication Date: September 2, 2001 | ISBN-10: 0201733862 | ISBN-13: 978-0201733860 | Edition: 1

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.

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

See all Editorial Reviews

Product Details

• Paperback: 208 pages
• Publisher: Addison-Wesley Professional; 1 edition (September 2, 2001)
• Language: English
• ISBN-10: 0201733862
• ISBN-13: 978-0201733860
• Product Dimensions: 7.3 x 0.6 x 9.2 inches
• Shipping Weight: 15.2 ounces (View shipping rates and policies)
• Average Customer Review: 4.3 out of 5 stars  See all reviews (24 customer reviews)
• Amazon Best Sellers Rank: #436,383 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

61 of 68 people found the following review helpful

3.0 out of 5 stars Dated examples, needs be focus on the problem August 18, 2002

By Glen B. Alleman

Format:Paperback

The thesis of the book, that Software Engineering has run its course and it is time to return to the master/apprentice approach, starts by citing the early days of software engineering. His working example of large scale software engineering is the SAFEGUARD system completed in 1975. This example is not very timely nor is it representative of a modern large scale development effort. Although SAFEGUARD presented many challenges to the software engineers of the time, it's lessons have long been absorbed into the practice of software engineering. In addition the SAFEGUARD system was one of the early discovery design projects. Not only did new hardware have to be built, but new and innovative software processes invented as well.

Software Craftsmanship presents a view that software developers should return to their craftsman roots in order to deal with the increasing complexity of today's development demands. McBreen makes the case that building software systems requires a set of skills and experiences beyond just book learning, training courses, methodologies, and CASE tools. A craftsman paradigm is presented in which an apprentice software developer learns from journeyman in much the same way other craftsman based professions do.

This concept is both interesting and timely in light of the recent failures of systems ranging from the FAA and IRS to dot-coms. McBreen presents this concept as a counter to software engineering methods (SWE), which he proceeds to blame for many of the woes of the industry.

Starting with the Preface, McBreen confuses the engineering aspects of software with software manufacturing. He quotes a 1969 NATO report from Naur and Randell, which is not only out of date, but inappropriate in todays software engineering discipline. This use of dated reference materials continues in many chapters and creates the impression that McBreen may not have done his homework.

His case against software engineering has useful points but many of the issues he brings up are well worn red herrings. His Big Project example is nearly 20 years old and in a domain unfamiliar to many - a ballistic missile defense system (the first such system). Surely we have learned something about software engineering in the intervening time since 1975.

McBreen approaches the issue of software engineer licensing as a potential threat to software craftsman. But he does not provide a balanced view for this topic, since the licensing of process system engineers writing software for mission critical systems has been in place for decades. A look at the European TÜV and SINTEF regulations would have provided some background on addressing this issue in the US.

One issue with the book is that it does not establish a context in which to discuss the topic of craftsmanship-based software development. Customer relationships, development processes, project management processes, examples of success and failure are not placed in a context. One place to look for a taxonomy of software projects and their attributes would have been the Capers Jones series. These texts provide a broad as well as deep view of the complexities of software development and the risks of naively apply one size fits all to a problem.

This one size fits all approach is addressed by McBreen in a later chapter. He states that ones size does not fit all, but then proceeds to provide advice and direction to the reader on how to apply craftsmanship methods in the absence of a specific problem domain. The process of developing craftsman-based software for a business application with an on-site customer is significantly different than developing software within a highly regulated or globally distributed corporation using COTS products.

Although there is much to offer in the book, I have some specific issues with the material, its sources - or lack of sources - as well as the overall tone for what is presented as a New Imperative.

found the book a stimulating read, although frustrating at times when I encountered comments like the Java one above. The major gaps in understanding might be attributed to McBreen's lack of experience in those areas. Gaps that could have been easily filled with research. These gaps I also attribute to poor copy editing, but that is another issue all together.

I would recommend the book, but with qualifications and caveats. The read should try to put the ideas into a context and ask are these concepts appropriate for my domain? Do the ideas make sense for the specifics of my problem? Does the specific statement actually make sense from my own experience and the experience of others? Have I seem a similar concept in a peer reviewed journal or are these simply the opinions of the author with an axe to grind?

McBreen gives credit to the SEI, Jones, Coplien, Highsmith, Cockburn and others, but he appears to have left much of their contribution out of this book and on the shelf.

17 of 18 people found the following review helpful

5.0 out of 5 stars Approaching Programming as a Craft October 25, 2001

By Robert Stevenson

Format:Paperback

For a long time, computer programming has seemed to me to be more akin to writing a symphony or a novel than constructing a bridge, despite the fact that the industry has tried to make it like bridge-building by treating programming as "software engineering" and trying to use engineering methodologies to control development. Pete McBreen's book goes a long way toward explaining some of the software development phenomena we see, and why so much software engineering practice doesn't seem to work. I've written test tools for lower-level software, and I've noticed that the usual engineering methodologies do not explain what I've seen -- some people's code is simply better than others with fewer bugs (this variation in programmers has been known for a very long time), and I'm not sure how fundamental improvement can be legislated in a programming department or by the government. The conventional wisdom does not come to address one fact: one of the most important factors in the quality of software is who is writing it. McBreen acknowledges this and suggests a road by which more programmers can excel -- he believes such "stars" can be made. And it's interesting how he ties in the present trends in Extreme Programming and the Open Source development community, as well as the old Chief Programmer Team model, to bolster his thesis.

McBreen presents an apprenticeship model for the development of programmers that actually has been done at times and places, although much less formally. My first programming job was something similar to this and stands in strong contrast to the world today where a new hire from college has a "software engineer" title and thrown into the deep end of the pool. I imagine many new graduates from MIT or Berkeley would be insulted at the idea of taking a job with a title "Programmer Trainee". Some of us have done just that.

This book is a great read, and, as with so many good books, it's too short. He presents the craftmanship model but the book cries out for more explanation on implementation and what has happened when it is implemented. Many of us cannot implement company-wide changes ourselves, however, we can see programming in a new light and possibly begin change, in our own work, how it's approached and written.

20 of 22 people found the following review helpful

5.0 out of 5 stars The Programmer as Artisan, not Engineer December 17, 2001

By "tekwallah"

Format:Paperback

This is the book for those of us who've read all the standard works on classical software engineering methods and can't lose the suspicion that they're WRONG.

Software Craftsmanship: The New Imperative revealed the one important fact about how software engineering was derived from giant government projects in the 60's and 70's that I didn't know: those projects included building the hardware on which the applications would eventually run. The reason for the emphasis on long, detailed requirements and design documentation is that this was the best use of the dead time software engineers had while the machine and its compilers were being constructed. As soon as the box was ready an army of coders was given the detailed design documents and converted them page-by-page into source code.

Programmers who have ever wondered why they were being paid high salaries and then treated as mindless drones now have an historical explanation.

Pete McBreen isn't the first person to question standard procedures for developing commercial software. The Open Source movement has proven that high quality, useful software can come from developers using no specification documentation at all. The eXtreme and Agile methodologies have shown it is acceptable for specifications to change during the course of the project: Customers will be more pleased with the final product if they can revise their requirements as they see the product developing.

So who could possibly be holding on to a methodology that is demonstrably inappropriate for modern small software groups developing commercial products? Mr. McBreen fingers managers whose pay and prestige depend upon head count. Turning every project into a relay race with analysts, designers, programmers and testers guarantees many billable hours while intellectual property is passed on from group to group. Preferentially hiring young, inexperienced programmers and capping the salary rate ensures a bloated staff with high care and feeding needs. It's a provocative assertion that will certainly engender debate.

McBreen says he wants to join in the public conversation that already includes the voices of Richard Stallman, Linux Torvalds and Kent Beck. His intelligent analysis of the origins of classical software engineering and why it is no longer a good paradigm for commercial software development will help keep that conversation informed and productive, as well as lively.

* Books mentioned by Mr. McBreen include:
The Pragmatic Programmer by Andrew Hunt and David Thomas ISBN: 020161622X
The Inmates are Running the Asylum by Alan Cooper ISBN: 0672316498