Product Description
Four top-notch authors present the first book containing a catalog of object-oriented design patterns. Readers will learn how to use design patterns in the object-oriented development process, how to solve specific design problems using patterns, and gain a common vocabulary for object-oriented design.Amazon.com Review
Design Patterns is a modern classic in the literatureof object-oriented development, offering timeless and elegantsolutions to common problems in software design. It describes patternsfor managing object creation, composing objects into largerstructures, and coordinating control flow between objects. The bookprovides numerous examples where using composition rather thaninheritance can improve the reusability and flexibility of code. Note,though, that it's not a tutorial but a catalog that you can use tofind an object-oriented design pattern that's appropriate for theneeds of your particular application--a selection for virtuosoprogrammers who appreciate (or require) consistent, well-engineeredobject-oriented designs. ... Read more

Customer Reviews (276)

A must have
This book is a must have for anyone in software design and concerned with good practices.

Excellent
One of the CS book will be on your bookshelf for rest of your life.

Exactly what I needed
Fantastic book, although written a while ago, it's extremely beneficial to be aware of the patterns raised in the book. Really well explained and gives great examples.

Rely
This purchase was OK. Thanks. The only inconvenient is that the first producto was lost, but amazon responded for it, that do rely to amazon. The other, this book is excellent. Thanks

poor explanation though important topics
thought it addresses an important topic, but neither the explanation nor the examples make it a good book. I just cannot find another book. ... Read more

Product Description

eXtreme Programming is an ideal many software shops would love to reach, but with the constant pressures to produce software quickly, they cannot actually implement it. The Agile software process allows a company to implement eXtreme Programming quickly and immediately-and to begin producing software incrementally in as little as 30 days! Implementing eXtreme Programming is easier said than done. The process can be time consuming and actually slow down current software projects that are in process. This book shows readers how to use SCRUM, an Agile software development process, to quickly and seamlessly implement XP in their shop-while still producing actual software. Using SCRUM and the Agile process can virtually eliminate all downtime during an XP implementation.

Customer Reviews (52)

Great Read
The book was a great read.It allowed me to build a business case on why we should begin moving from a waterfall / iterative process model to an agile process model.It also gave a good demonstration on how to go about implementing the agile process model.

Enough to show you a bit about the ins and outs of SCRUM
The author describes Scrum through a series of personal professional experience while using scrum to manage projects throughout different kinds of clients and situations and tries to demonstrate what you should do if you find yourself in one of the situations mentioned in the book.

While a really interesting reading, it gets a little tired as the book progresses through project descriptions and scrum concepts, after the third or fourth use case I was almost giving up.

Still a good book and I would recommend it if you would like some nice introduction to Scrum.

Insightful
The book is an easy read, knocked over in half a day. Has a lot of great learnings and insights. Of course its biased to AGILE being the savour, despite that it is still worth the read.

Not without value
This book has been mostly a disappointment. It is sloppily written, repetitious, and doesn't seem to have a lot of points to make. I have definitely learned some interesting things about the scrum process from the book, but I feel like it could have easily been one quarter the length and still accomplished the same goal. The level of workmanship which went into this book is truly pathetic - the figures are horribly pixelated to the point where they are barely readable, and the editing was definitely subpar. This may be a book which is worth skimming, but I hardly think it's worth reading carefully.

a great read
158 pages short, but dense with useful information. a great and motivational intro to Scrum. just the right amount of examples vs theory. highly recommend to any beginner, yet it's probably wholly appropriate to any experienced scrum practitioner that wants to remember the basics. ... Read more

Product Description
Learn proven, real-world techniques for managing the software requirements engineering process. This award-winning book has been expanded with new topics, including use cases, up-to-date tools, more field examples, and a new troubleshooting guide.Amazon.com Review
"Requirements" are essential for creating successful software because they let users and developers agree on what features will be delivered in new systems. Karl Wiegers's Software Requirements shows you how to define and get more out of software requirements with dozens of "best practices" and tips that make this book a valuable resource for both software project managers and developers.

The book's commonsense approach provides exemplary project management skills tailored to gathering (and refining, implementing, and eventually tracking) software requirements. While the book often cites recent software engineering studies, the focus always returns to practical management techniques. A case study for a chemical tracking application frames the book, and most chapters begin with anecdotes that demonstrate situations in which users and developers misunderstand each other about a software project's ultimate goals. (If you've ever worked in the field, these stories will probably sound all too familiar.)

This book offers hope, though, for improving your software design process, with dozens of tips on getting better design input from your customers and then using these requirements to generate a variety of design documents. There are numerous templates and sample documents too--a big help for the busy software manager.

Several standout sections cover negotiating difficult steps in the process, particularly how to manage shifting requirements as projects move forward and keep the various users and stakeholders content throughout the software process. Late in the book, the author surveys today's software management tools and shows how to pick the right ones for your organization.

Anchored by the author's considerable experience and software engineering expertise, this jargon-free and practical guide to software requirements can definitely give you the edge in managing software projects more efficiently. --Richard Dragan

Topics covered: software requirements specifications (SRS); business and user requirements; risk management; the requirements process; sample documents and templates; requirements development: elicitation, analysis, specification, and verification; rights and responsibilities for software customers; best practices; project management tips; process assessment and improvement; types of users; product champions; use cases and other diagrams; tips for prototyping; managing requirements change; change centered boards (CCBs); evaluating and using requirements tools; requirements traceability matrix; impact analysis. ... Read more

Customer Reviews (51)

Excellent book
The problems he describes are recognisable, and the solutions he proposes are practical usable practices. Not too theoretical. One of the things he explicitely mentions is that one can tailor the practices to your own organizational needs. The suggested practices and templates give you a head start.I felt during reading that he really understood I issues that come with requirement engineering. Also the 'goodies' givin on the website are valuable additional 'assets'. Nice piece of work! I advise anyone interested in requirements to read this book.

Very Comprehensive
If you are a beginner to requirements management, I can't think of a better place to start. It contains a chapter on just about every aspect of requirements and even touches on Project Management (the 2 areas are closely related).

Why did it lose 1*:
- the book is a little dated .. it reads like Karl started by promoting the SRS type document to capture requirements, but as the book progressed he started to promote use cases, (which have become more widely accepted in the last 10 years).
- some of the examples are flawed. This is perhaps an unfair criticism, because I may be finding flaws that few other people will spot, and they do not detract from the value gained from reading the book.
- too many words and not enough examples. This is a criticism that I level at almost all technical books of this nature. Karl's is no different in this respect.

One of the better books for anyone needing to learn about requirements management.

Helpful
I purchased this book for work. It has proved helpful to several of my co-workers. I hope to get lots of use out of it.

Worth your time
For the most part this is rather informative and practical text.

Positive: It establishes an importance of solid software requirements process. Without solid requirements process, software engineering/development is doomed to be extremely painful for stakeholders, developers, and pretty much everyone involved in the project. After reading this book you will have to reconsider the importance of requirements engineering as foundational to the project success. It give practical examples on development SRS (soft. requirements specifications) and Vision and Scope document.

Negative: Some sections are not well elaborated (which is understandable, due to the nature of the specific subject of the book). For instance, when it deals with various diagrams, I would rather recommend reading other supplemental texts to give you better understanding of various diagrams, and their use. As you may know, for example, in ERD, it is not advisable to have M:N relationships (many-to-many). But of course SOME specific situations may require otherwise.
Other thing I did not like, is invisible to the most readers couple expression found in the book on p. 214 "Avoid getting caught up in the dogmatic mindsets and religious wars that sometimes take place in the world of software development methods and models. Instead use what you need to best explain your system's requirements". Here, while the underlying idea is somewhat valid, the wording is not.
1.) "Avoid getting caught in the dogmatic mindsets" - is in itself pretty much sound like a dogma.
2.) "Religious wars" - is somewhat disrespectful to the question matter of the ultimate reality - i.e. God. Unless you are Freudian, Marxist, or otherwise secular naturalist, there is no reason to compare "religious wars" to the political wars, where second is well known show. In other words, I wold appreciate author not using religious terminology, or comparing religious language to the politics.

All in all, this is practical and informative book about requirements engineering.

Recommended.

Great overview on methodology of requirements gathering
Wiegers' book is one of the standard references for requirements gathering that's around. We have these on our shelves at our company for all the analysts and while there are other references around on project management and project implementation, this book has outlines of all the different parts focusing on requirements gathering:gathering participants on the project and client side, setting expectations, how to document, what your first steps are as well as the pitfalls. Every analyst needs this on their book shelf as a reference. ... Read more

Product Description
“This new edition is brighter, shinier, more complete, more pragmatic, more focused than the previous one, and I wouldn’t have thought it possible to improve on the original. As the field of software architecture has grown over these past decades, there is much more to be said, much more that we know, and much more that we can reflect upon of what’s worked and what hasn’t—and the authors here do all that, and more.”

—From the Foreword by Grady Booch, IBM Fellow

Customer Reviews (10)

The Best Just got Better....
This book is the bible of documenting software architectures.It is a mandatory read for all software architects.It should also be read by the various stakeholders who have invested in a software architect so they have some idea about what their investment should be accomplishing.

This version includes a lot of new content.It includes new architectural styles for SOA, database models, and multi-tier architectures.

The authors have expanded the epilogue which is the comparison of Views and Beyond to other documenting approaches.It now includes comparisons to ISO/IEC 42010 - ANSI/IEEE Std 1471-2000, the RUPs 4+1, Rozanski and Woods Viewpoint Set, agile projects, and DoDAF.

The book now includes 3 appendixes.One on UML, SysML, and AADL.Each is an overview of the language.

They have improved templates based on experience gained since the first version of the book.

The book's example is now on line.It documents a Web-based service-oriented system.

This book shows you how to communicate with your stakeholders and how to address quality attribute requirements like no other book out there.I am not saying it is the best book out there, I am saying it accomplishes what it tries to teach.It creates a view of a great method of documenting architecture.It then provides a cross reference with some other great methods of documenting software architecture in the epilogue I mentioned above.

It is a must read for any architect that takes there job serious.It will add a wealth of knowledge to your arsenal of tools.

Rich book that deserve to be read
I had to read this book in a software engineering course. Usually, those mandatory books that student must buy for their course are finally mostly used as reference or additional documentation. In this case, this book was as much important as the entire class. It covers a wide range of topics selected by the teacher and even more.

This book is hard to read because there is a lot of important concepts and ideas in every single chapter. View types, styles, some basic tactics, how to choose what to include in a view, how to present your document, how to combine views, etc.

The only annoying point is that they wrote many times in their book that a View must come with a key to explain its notation. However, we can find many of theirs example of a view that haven't any key. But except for these errors, it is an excellent book.

A master guide on Architecture Documentation
Documentation is one of the main duties of a Software Architect. A master design, poorly documented, will most probably be poorly implemented. This book is an excellent guide to create long lasting documentation that effectively conveys your design and helps guides your project from conception all the way to maintenance.

It gives great insight on how to successfully target your different audiences and explains in a clear and concise way a lot of the terminology used in the most widely adopted architectural styles.. The way the documentation packages are explained and organized creates a convenient and easy to follow catalog, allowing your stakeholders to employ your documentation as a reference that they keep visiting over and over again throughout the entire life-cycle of your project.

The book is also organized in a way that it can be used as a reference book by the Architect or as a documentation companion for developers and business users; there are different "paths" through the book, targeted to different audiences and conveniently outlined on the preface.

I can't wait for the second edition to come out! (already pre-ordered)

Easy to buy
I live abroad USA and Received rhe problems without problems. For me this is a good choice to buy books that doesn't translate yet.

JoseWilton - Brazil

The best thinking on documenting software architecture
Simply put, I think this book represents the best thinking about documenting software architectures. You can find other books that include different aspects covered in this book (documenting views, 4+1, ANSI/IEEE-1471-2000, etc). However, you will have a hard time finding a book that pulls it all together, provides the rationale and includes the "beyond" part which discusses other approaches to documenting software architectures and how they relate to the "Views and Beyond" (V&B) approach. For instance, the book discusses how to use V&B to comply with ANSI/IEEE-1471-2000. ... Read more

Product Description

Lean Software Development shows software professionals how to achieve breakthrough quality, savings, speed, and business value by adapting the seven "lean" principles that have already revolutionized manufacturing and R&D. Drawing on 25+ years' experience leading enterprise projects, the authors show how to use these principles to create agile processes that work - because they're optimized for your environment.

Customer Reviews (45)

Content that stands the test of time
"Lean Software Development: An Agile Toolkit" is not only an excellent introduction to lean principles, it also offers a great deal of wisdom about successful software leadership.The early chapters in the book offer pragmatic explorations of lean principles, with tangible examples of what might be foreign concepts.It tackles concepts such as: waste, value stream mapping, set-based development, concurrent development, and queuing theory and how these principles can be applied to software development.

The book is packed with gold nuggets like this comment regarding trying to run development teams at 100% of their capacity all the time: "We would never run the servers in our computer rooms at full utilization - why haven't we learned that lesson in software development?"

Perhaps the best chapter is the last, where the authors identify many of the common pitfalls encountered with agile software development.If you want to know the danger signs to watch for, start with the last chapter first.The final chapter also contains useful advice regarding compatibility with Six Sigma environments, but missed the mark on CMMI and PMI in my opinion.

While the practice of agile development has matured in the years since this book was published, its content stands the test of time.It is a great introduction for those new to lean or agile software development, and a great refresher of important principles for the experienced practitioner.

Lean Software Development, an Agile Toolkit
Lean Software Development, an Agile Toolkit is the third book that I have read on agile development.Even though the book was written in 2003 there are countless gems (take aways) that you can start implementing on your team now.Some are harder than others, such as set based design and the kanban pull system.However, it would be great practice for a team to give them a try during their release.

The book covers seven high level topics and dives fairly deep into each one.The topics that I found most valuable were eliminate waste value stream mapping in chapter one.Deciding as late as possible or the concept of, "the last responsible moment" in chapter three always interests me.In chapter four "deliver as fast as possible" was very interesting to me because it reminded me of times when everything just was working so well together within a team that the fly wheel almost flew off the tracks.This chapter gives good insight into how to make that happen for your team.Finally, in chapter sever, "see the whole," I never would have even thought about suboptimizing a team to get better performance was probably one of the most insightful points of the book.Their explanation and analogy of why a team would want to do this really stuck with me.

Overall, I believe that this book should be a staple on every agilest book shelf.I can't wait to get my hands on the other two Poppendieck books.

A good read for anybody in business
Being new to Agile, I am a Project Manager with waterfall experience.I enjoyed the book Lean Software Development An Agile Toolkit by Mary & Tom Poppendieck.I think the Lean concept as described in this book lends itself well to Agile methodologies.

The book brings you into the basic concepts and brief history of Lean and expands into the process and ideas of how an organization can go about reducing waste and increasing productivity.The idea of Value Stream Mapping and Set Base Development were great concepts that I was introduced to.What I really embraced in this book is the human quality that Lean can bring into an organization by empowering individuals and teams members to act with authority, bringing about continual process improvements.With this new found empowerment individual ownership takes place, improving moral, fostering a cycle of continual process improvements.This in turn will help the organization to be able to produce a better quality produce in less time with increased customer satisfaction.

I recommend this book to everybody, it is well written, short, and its concepts relevant to any business.

A slender introduction to lean
"Lean Software Development: An Agile Toolkit," by Mary and Tom
Poppendieck, is a good introduction to lean concepts and how they can
be applied to software development.The book is clear and concise,
clocking in at a mere 186 pages, which is in contrast to some lean or
agile books which span over 500 pages and tend to make my eyes glaze
over.It focuses on many different areas of lean thinking, but my
main takeaways were a better understanding of set-based development
and team empowerment

Amplifying learning is the key lean concept that set-based product
development is rooted in.The Poppendiecks do a good job of
explaining how developing different implementations of features and
communicating constraints instead of solutions help teams arrive at a
solution that is optimal for the customer.Likewise, the Poppendiecks
also describe empowering teams rather than burdening them with too
much process.This is a common theme in agile and lean, that you
develop as much process as is necessary and only that much.If you
have a smart and motivated team, they should be able to thrive in such
an environment.The Poppendiecks excel at giving a wealth of advice
in a single chapter on this subject.

In conclusion, "Lean Software Development" is a solid introduction to
the core concepts of lean.It could have been improved by expanding
on root cause analysis and the 5 Whys method of inspection.As well,
there was no discussion of A3 Reports.Despite these shortcomings, I
would certainly recommend this book to anyone who is just starting out
on their lean journey.

Recommended Reading
It was seven years and many software projects ago when I first read this book. At the time, I was trying to get my arms around the rapidly emerging agile movement. I enjoyed reading and learning about the practices for XP, Scrum, Crystal and other methodologies. However, this book helped me see the bigger picture and introduced me to valuable concepts from lean manufacturing such as value stream mapping, set based development and pull systems.

The book also introduced me to a lean, systems-based way of approaching software development. Although I might have been pressed to enumerate all the principles and the tools in the book, I know that over the years I've applied many of them regularly- adapting them to fit the diverse domains and environments in which I worked. Over the years, my copy has became worn and dog-eared. It was marked with a yellow tag on the spine, my way of marking favorite books on my shelf. As such, it was often loaned out to others.

I recently re-read the book and was surprised how relevant it remains in 2009. A few of the specifics in the book are dated, such as its characterization of how CMM, CMMI and PMI relate to agile. However, most of the material, is not only relevant; it's often more applicable today than when it was originally written. The book is well organized, easy to read and filled with "pearls of wisdom". I'll continue to include it right next to Goldratt in my list of recommended reading.
... Read more

Product Description
This book will teach you how to test computer software under real-world conditions. The authors have all been test managers and software development managers at well-known Silicon Valley software companies. Successful consumer software companies have learned how to produce high-quality products under tight time and budget constraints. The book explains the testing side of that success.

Who this book is for:
* Testers and Test Managers
* Project Managers-Understand the timeline, depth of investigation, and quality of communication to hold testers accountable for.
* Programmers-Gain insight into the sources of errors in your code, understand what tests your work will have to pass, and why testers do the things they do.
* Students-Train for an entry-level position in software development.

What you will learn:
* How to find important bugs quickly
* How to describe software errors clearly
* How to create a testing plan with a minimum of paperwork
* How to design and use a bug-tracking system
* Where testing fits in the product development process
* How to test products that will be translated into other languages
* How to test for compatibility with devices, such as printers
* What laws apply to software qualityAmazon.com Review
The original printing of Testing Computer Software setthe standard for the emerging field of test engineering with a fulltour of the state of the art in managing the testing process. Thereissued text makes this classic out-of-print text available onceagain. Though it relies heavily on older examples (including MS-DOS)and has not been updated, this text is still a worthwhile resource forpractical-minded advice on the realities of testing.

The best thingabout Testing Computer Software is its practical point-by-pointguide to everyday software testing, from creating a test plan, towriting effective bug reports, to working with programming staff andmanagement to fix bugs.

That said, this book's early frame ofreference shows how far we've come. (The book relies heavily on MS-DOSexamples and features some truly embarrassing anachronisms, includingthe mention of testing dot-matrix printers and even EGA/VGA videomodes.) The bibliography stops at sources from 1992 and features manyreferences from the 1980s. Nowadays, automated software testing toolsare the staple of any testing strategy. This book even advocates await-and-see approach to the "new" Microsoft Test.

Theselimitations aside, there is still a good deal to mine here. Much ofthe approach to testing is still very valid for any aspiring orworking test engineer. Clearly, readers of the first edition will havelittle reason to upgrade to this second edition, but for anyone whoappreciates a "classic" (and indeed a pioneering) text in the field ofsoftware testing, it's good to have Testing Computer Softwarein print again. --Richard Dragan

Topics covered: testcase design, test planning, project lifecycle overview, softwareerrors, boundary conditions, bug reports, regression testing, blackbox testing, software quality and reliability, managing test teams,printer testing, internationalization, and managing legal risk. ... Read more

Customer Reviews (45)

EXcellent book on testing - especially for novices
This will be an authoritative source on testing for someone like me that needs to understand the concepts and lacks the experience needed.I can't imagine any title being more useful for someone in my new role.

Exactly what I expected
I received exactly what I expected in the condition in which it had been listed. Since I'd had the book before, I knew the content.I was concerned about the condition. If anything it was in better condition than the seller had stated.

New to testing...
A friend recently suggested I get into Software testing and honestly I never thought about it as a career choice.She suggested this and one other book as informative sources to get me started.Finding books on the subject alone was hard enough!

I haven't finished the book yet, but here's what I like

- Information is simply written and easy to understand so far. Not all text books do that and I appreciate when it is.

- This book isn't just geared to the subject matter experts or even people new to the subject. The preface addresses this and offers suggestions

- Each chapter starts by the writers telling you why that section is necessary, a brief summary and sometimes even outside references to follow up with.

The only bad thing I can say so far about this book is that there doesn't seem to be any updated versions.While I'm assuming that methodology doesn't really change, the book is already ten years old.I'm hoping that my opinions don't change as I get more in-depth, but if they do I'll come back and update this review.

Written by bureaucrats while they were on their vacation in an Ivory tower, long long time ago...
This book , in its most part, talks about the bureaucracy of testing not testing itself. The technical aspects, hints, tips, guidelines are all almost absent.

The book barely scratches the surface of the different kinds of tests and their related technicalities, e.g. unit test, Integration test, Regression test....etc... to add an insult to the injury, the brief mentionings of the tests are scattered in different parts of the book, so confusing. I would've imagined the book to lay them out in one chapter, compare them, show Strengths and Weaknesses for each test, write down the cost in terms of orders of magnitude and state at what phase of the project each test is invoked and how often....all that is missing...if that is what you looking for, you wont find the answer in this book.


What this book talks about, is who should report to who, how to approach developers and managers, how to format a bug report, how to test user manuals. Very superficial view of testing, the last two chapter, almost a 100 pages, out of 400, talk about how to manage a group of testers and legal consequences of testing! There is a chapter about testing printers, it is supposed to be an example of how to test, you will find the author talking about fonts and how printers work more than how to test them. There is a chapter about localization and globalization, again, it uses German, a language that English itself is derived from, as an example rather than using complete alien languages that are from right to left or from top to bottom with different letters, Hebrew,Arabic or Chinese.

The book assumes that every project has to go through certain bureaucracy, and based on that assumption it tells you what to do, but these assumptions only apply to big critical software projects that have many people working on them, like nuclear reactors or medical software, where the risk is too high, it's an overkill for testing and offers so little for the majority of the software industry crowd that works on small to mid size projects.


The book is outdated, you will find it recommending most of the books from the 1970's and early 80's...it is supposed to be a second edition and I have reasons to believe that since the first edition in 1988 there are a lotof good books out there. Also, when it mentions test tools, I haven't heard anything about nunit or junit or any of the famous testing tools or anything that even sounds like them,

Don't let the fact that it is a best seller fool you as it did to me, the book has been out for a while...there is only one thing wrong about CODE COMPLETE 2...IT RECOMMENDS THIS BOOK

Not for Computer People.
Within 5 minutes of looking at the book, I can definately say that the information is NON-TECHNICAL.It outlines stories of lawsuits regarding products, what to do when you are a manager, how to fill out a QA sheet.Not good if you are interested in programming.
BTW: publish date is 1988, not found on the amazon profile. ... Read more

Product Description
Decades of software testing experience condensed into the most important lessons learned.

The world's leading software testing experts lend you their wisdom and years of experience to help you avoid the most common mistakes in testing software. Each lesson is an assertion related to software testing, followed by an explanation or example that shows you the how, when, and why of the testing lesson. More than just tips, tricks, and pitfalls to avoid, Lessons Learned in Software Testing speeds you through the critical testing phase of the software development project without the extensive trial and error it normally takes to do so. The ultimate resource for software testers and developers at every level of expertise, this guidebook features:

• Over 200 lessons gleaned from over 30 years of combined testing experience
• Tips, tricks, and common pitfalls to avoid by simply reading the book rather than finding out the hard way
• Lessons for all key topic areas, including test design, test management, testing strategies, and bug reporting
• Explanations and examples of each testing trouble spot help illustrate each lesson's assertion

Customer Reviews (41)

Good Stuff
This book is really readable and packed with practical information.Any reader is bound to walk away with something of real value and use.This book will certainly be staying close at hand for future reference.

Amazingly good book on software testing
Other reviewers have given enough detail on why this is such a good book.But let me reiterate, this book is important, and worth more than its weight in gold.

Good Book
Like the Title says it is a collection of Lessons Learned in this trade. Nice book and has real experiences that I had come across. Overall its a good book and would recommend all levels of QA people to read this.

Very practical and useful
The book is a very good tool for those who are part of a software testing team or are in some way related to one. The text goes straight to the point and gives good ideias about how to handle the testing effort and how to improve your skills on the testing area. I believe it is a must have for those who take testing seriously.

Many insights into testing
"Lessons learned in software testing" provides 293 lessons the authors learned during their many years working as software testers, test managers and consultants. This book is perhaps one of the most insightful books on testing ever written. It covers a broad range of testing issues and most of the topics are relevant outside the world of testing. To give an example, the authors discussions related to documentation, standards or licensing are not limited to testing. They clearly explain their thinking behind their arguments and parts like these are useful reads for anyone!

The book is organized around 293 lessons which are a paragraph to a couple pages long. The lessons are organized around eleven chapters. At first, I was annoyed by the structure of the book, but as I got used to it, I started to appreciate the structure in different lessons. Especially since it helped the authors in expressing conflicting thoughts well.

The first chapters cover the most basic questions. The first is about the role a tester has and already here the authors present a perhaps controversial view on testing as a service as opposed to as a quality police, which is often seen in larger organizations. The second chapter relates to how to think as a tester. It provides interesting references in completely different knowledge areas which might help testers become better. The third chapter is somewhat misplaced in the book, though still useful. It's a chapter that covers different testing techniques. It doesn't cover it thoroughly, but that is not the purpose of this book. For more thorough coverage of testing techniques, its probably better to pick up another book.

The fourth chapter is about writing bugs. Its insightful since it especially clarifies a lot about the role of testing from the authors perspective. The fifth chapter covers test automation and makes important observations related to test automation... especially that test automation is not the same as automated manual testing. I found the wording insightful and again stresses the role of the tester and especially the skill of testers.

Chapter six is perhaps one of the more controversial ones about documenting testing. As a logical conclusion from the focus on the role of tester (mentioned earlier), it makes sense to limit the documentation somewhat. Documentation is not a substitute for skill. However, they provide a balanced view and do not recommend to throw your documentation out of the window, but instead analyze your particular situation and create only the documentation that is needed.

The next three chapters relate to working with other persons. First how to work with programmers, then how to manage a testing project and how to manage a testing group. Chapter ten relates to building a testing career. Also here, some of the advise is general to "a career", not specifically a testing one.

The last chapter about strategy seemed to me somewhat odd. The book would have ended well with the manage your testing career and its not totally clear to me why the authors added this chapter still. It's not useless, just doesn't seem to fit in very well.

All in all, the book is a good read! It's funny and very insightful and sometimes controversial. I was considering a rating of four or five stars. I was thinking about four since I did not always agree with the authors for example, on their views on test automation. Though, lots has been learned about that the last years! On the other hand, I do not know any more insightful book related to this subject. And, I'd even recommend it to people who do not do software testing at all! So, therefore I decided to go for five stars! Well worth reading! ... Read more

Product Description

Getting software released to users is often a painful, risky, and time-consuming process.

This groundbreaking new book sets out the principles and technical practices that enable

rapid, incremental delivery of high quality, valuable new functionality to users. Through

automation of the build, deployment, and testing process, and improved collaboration between

developers, testers, and operations, delivery teams can get changes released in a matter of hours—

sometimes even minutes–no matter what the size of a project or the complexity of its code base.

Jez Humble and David Farley begin by presenting the foundations of a rapid, reliable, low-risk

delivery process. Next, they introduce the “deployment pipeline,” an automated process for

managing all changes, from check-in to release. Finally, they discuss the “ecosystem” needed to

support continuous delivery, from infrastructure, data and configuration management to governance.

The authors introduce state-of-the-art techniques, including automated infrastructure management

and data migration, and the use of virtualization. For each, they review key issues, identify best

practices, and demonstrate how to mitigate risks. Coverage includes

• Automating all facets of building, integrating, testing, and deploying software

• Implementing deployment pipelines at team and organizational levels

• Improving collaboration between developers, testers, and operations

• Developing features incrementally on large and distributed teams

• Implementing an effective configuration management strategy

• Automating acceptance testing, from analysis to implementation

• Testing capacity and other non-functional requirements

• Implementing continuous deployment and zero-downtime releases

• Managing infrastructure, data, components and dependencies

• Navigating risk management, compliance, and auditing

Whether you’re a developer, systems administrator, tester, or manager, this book will help your

organization move from idea to release faster than ever—so you can deliver value to your business

rapidly and reliably.

Customer Reviews (3)

Well written book.
I had to find out ways to improve product delivery mechanism to ensure updates reach the production server.we are already into agile / scrum methodology.it has worked very well for meeting deliverable dates and providing good value to customers.this book went through the whole process of helping us move the updates/changes to the production line easily.


Well written - i did not fall asleep reading the book. Kept me awake and energetic.

Regards, Ravi Kaushika, Fort Worth, TX.

How to deliver software to users at the click of a button
This is one of the most important software books published in years. From the beginning and throughout the book, the authors emphasize the importance in establishing one delivery team consisting of various experts throughout the software lifecycle - developers, DBAs, Systems/Operations, network specialists, testers and so on. The overarching pattern the authors describe is the Deployment Pipeline, which is basically a staged process consisting of all of the steps to go from bare/virtual metal to a working system whenever there is a change to source files. Of course, the only way this can be done is through copious amounts of automation. The other key point the authors make is that this automated delivery system - itself - is versioned with every change. Not just the custom source code, but also the operating system(s), tools, configuration and everything necessary to create a working software system - a crucial aspect of the Deployment Pipeline.

To sum up key points from the book in a few bullets:

* The purpose of Continuous Delivery is to reduce the cycle time between an idea and usable software
* Automate (almost) everything necessary to create usable software
* Version complete software systems (not just source code) for every change committed to version control system
* Employ a Deployment Pipeline in which the entire system is recreated whenever a change is committed to the version-control system and provide continuous feedback
* Identify one delivery team consisting of various delivery experts - build, deploy, provisioning, database, testing, etc. - a concept emphasized in the DevOps movement

The authors go into great detail in describing each of these themes. So, if you want the process of delivering software to any target environment - including production - to be a click of a button and something that can be accomplished as often as the business requires, get this book. When you employ the practices in this book, no longer will you need to artificially throttle changes delivered to users for months or even years because of the expense and risk required to deliver software.

A very important contribution
My first impression was, as the book title suggests, that the book is strictly focused on delivery of software, delivering continuously, to add value to the system and to satisfy the customer (all changes should satisfy the customer and should add value!). That is one crucial aspect for sure. But it is also possible to "deliver continuously" by just throwing changes to production randomly, in bad quality. Thus a systematic process of staging of software is crucial, and introducing (how I call it) "Quality Gates" is essential for releasing software quickly and in best quality.

Continuous Delivery advocates a closer collaboration between all stakeholders that are involved in the software development process. It delivers a holistic approach to software engineering. The book underlines the importance of aspects like Continuous Integration, acceptance testing and component repositories, and discusses many common and valuable best practices. It discusses questions that are relevant for different project phases and stakeholders. The book delivers the authors' views and opinions in a very informative way.

The book does not discuss all possible questions along all development phases (just not possible). It assigns priorities where, in some cases, you may miss another controversal aspect of the discussion (e.g. in the context of "keep absolutely everything in version control"). The pragmatic discussion of "configuration management" will be helpful for many teams, though. In other cases, you may miss another hint or little step. One example for that is in the context of "meaningful commit messages". Here, the potential of task-based development is not really illustrated, maybe because due to the next fact: The book does not (or rarely) show how to implement the strategies with tools. Some sections illustrate tools. Because it is not possible to cover all build tools for all different languages and platforms in one book, such sections give you a nice first impression, though. But for me, these sections are optional for such a book, for a book that is platform/language agnostic. These points are not disadvantages or drawbacks, you should just now them. As always, you should read the Preface first, to understand what this book is, and what it is not. Such a great book cannot cover every single aspect. And there are books like "Agile ALM", which assign other priorities, add other aspects to the discussion and are more targeted to a specific platform/audience (Java/JEE).

Continuous Delivery illustrates an approach that "all code changes are entering a pipeline" to production. I like this nice metaphor for promoting software, staging artifacts from the development team to the final release in production. Some people may claim that this is part of "release management", others may say it is similar to Continuous Integration, and "Continuous Deployment" (deploying versions to production, and to test machines before, continuously). - In my opinion, a change may result in a release *potentially* and *may* start the whole process. And: no changes to the production system without any process; most of the changes will be staged along the full way. The process and the infrastructure must enable the team to promote every single change to production, if you want to do that, however.

Additionally, I think that you should take special care of linking all artifact types to consistent releases, and that you should realize the "pipeline" not as something like a "fire-and-forget" tube. In my opinion, development phases are connected and integrated, and in most cases, it is (hopefully) more an integrated lifecycle, something like a pipline, where both ends of the cube are connected with each other.

Continuous Delivery is a very important contribution. I recommend the book to everyone involved in software engineering.
... Read more

Product Description

Proven, 100% Practical Guidance for Making Scrum and Agile Work in Any Organization

This is the definitive, realistic, actionable guide to starting fast with Scrum and agile–and then succeeding over the long haul. Leading agile consultant and practitioner Mike Cohn presents detailed recommendations, powerful tips, and real-world case studies drawn from his unparalleled experience helping hundreds of software organizations make Scrum and agile work.

Succeeding with Agile is for pragmatic software professionals who want real answers to the most difficult challenges they face in implementing Scrum. Cohn covers every facet of the transition: getting started, helping individuals transition to new roles, structuring teams, scaling up, working with a distributed team, and finally, implementing effective metrics and continuous improvement.

Throughout, Cohn presents “Things to Try Now” sections based on his most successful advice. Complementary “Objection” sections reproduce typical conversations with those resisting change and offer practical guidance for addressing their concerns. Coverage includes 

• Practical ways to get started immediately–and “get good” fast
• Overcoming individual resistance to the changes Scrum requires
• Staffing Scrum projects and building effective teams
• Establishing “improvement communities” of people who are passionate about driving change
• Choosing which agile technical practices to use or experiment with
• Leading self-organizing teams
• Making the most of Scrum sprints, planning, and quality techniques
• Scaling Scrum to distributed, multiteam projects
• Using Scrum on projects with complex sequential processes or challenging compliance and governance requirements
• Understanding Scrum’s impact on HR, facilities, and project management

Whether you've completed a few sprints or multiple agile projects and whatever your role–manager, developer, coach, ScrumMaster, product owner, analyst, team lead, or project lead–this book will help you succeed with your very next project. Then, it will help you go much further: It will help you transform your entire development organization.

Customer Reviews (24)

Book for the knowledgable
The book so far is great, (I am half way through it), but it is not for the "new to Scrum or Agile."I am fairly new to Scrum and Agile and although this has been very beneficial, it does not give in depth break down of what those two are.If you have some familiarity with those topics and you looking for a great book to fill in the holes with real world examples and guidelines, this is the book for you.If you are brand new to the topic, there is a bit of "ramp up" docs you may want to read before you get into this.

Book review
I started to read this book after finishing the book of User Stories Applied from the same author and I have to say that it is perfect combination. The book gave me better overview of SCRUM and agile methodic. I really like writing style of this author and the way of persuading agile things. I enjoyed reading and I'm giving it strong recommendation.

Utterly useless and really remarkbly vacuous
This book, according to its introduction, is intended to advise people on how to accomplish "the harder stuff" involved in Scrum.Okay.So let's look at what it has to say about one problem that is commonly considered to be hard with respect to Scrum: getting programmers to work in pairs.

I assert that is hard for two reasons.First, the folk who are responsible for paying the programmers tend to worry that they will be getting half of the former value for their money.Second, every one of many documents on agile and extreme programming that I've read refers to the cultural problems generally encountered in leading programmers to work in pairs.

What does this book have to say about solving this presumably hard problem?Well, out of 450 pages, there are 2-and-a-half on the subject.One might already draw a conclusion about the quality of the book from the fact that the subject does not show up at all in the table of contents; if one reviews the table of contents, one finds instead uninformative headings like, "Strive for Technical Excellence."Turning to the 2-and-a-half pages, found via the index, one finds that 1-and-a-half of them relate an anecdote from the author's career by which he claims to invented pair programming.Then there is a half-a-page stating just the most obvious obvious objections.Finally, there is a paragraph suggesting that pairing explicitly be added to the sprint backlog.

A half-hearted brainstorming session could presumably generate at least half-a-dozen other suggestions.Given that list, one might like to know which of those might be effective given the experiences of other organizations.Well, one might find that sort of information in H. Kniberg's rather wonderful "Scrum and XP" book for a fraction of the price, along with a lot of other good, reasoned insights.One would look in vain for more in Cohn's book.

I was pleased to see that "Succeeding with Agile" has a logo, "A Mike Cohn Signature Book" on the cover.That will help me avoid some other books that I won't be buying in future.It joins several books by Thomas Erl on service-oriented architecture as among the worst books on software development that I have had the misfortunate to encounter.

If you can only buy 1 book on Agile...
I do a lot of public and private training in Agile software development. Since Mike's book came out, I have made it a point to tell my customers that if they could buy just one book on Agile and Scrum, this is the book to get. It is both an easy read and a great reference on nearly every issue that we encounter when helping companies and teams adopt an Agile approach. Mike has a vast experience in the area and a talent for sharing it a way that is clear, concise and helpful.

The most practical guide to agile available
Mike Cohn continues in his tradition of writing some of the most practical books available in the agile environment.His vast experience is evident in his approach to presenting the many questions practitioners and newcomers alike consider as they move ahead with agile practices.Without being dogmatic he provides the pros and cons of the issues at hand, helping to understand why one approach might be more desirable than another.As one example, in presenting the difference between feature teams and component teams, it would have been very easy (and overly simplistic) for Mike to indicate that feature teams are the way to go.Instead, he acknowledges that feature teams are strongly recommended, but that component team might be the right choice in some situations, and he explains what those situations might be.

This book also makes a great reference.Have a question about the role Human Resources play in an agile environment?Look it up in the index and get some pertinent information without a lot of wading through other non-related material.

The littering of "Objection" and "Things To Try Now" notes again add some very practical applications, both in dealing with common obstacles encountered while implementing agile practices, and also in recommending ways to move the cause forward without a lot of fuss.

One very minor style critique: while I appreciate the extensive use of supporting reference material, the manner in which these are inserted into the book can be just a bit tiresome, almost giving a feeling of reading a research paper.I'm not sure that there's any way around this, and there's no contest between getting the supporting references vs. losing some of that to attain a style objective:the extra detail wins hands down.

As an indication of the overall quality of "Succeeding With Agile" we have decided at Winnow Management to now use this book as our primary recommended reading to our clients.Great work, Mike! ... Read more

Product Description

Foreword by Kent Beck

"The authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows.” --Ward Cunningham

“At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper.” --Robert C. Martin

“If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book.”--Michael Feathers

Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this "simple" idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and “grow” software that is coherent, reliable, and maintainable.

Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you’ll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes

•   Implementing TDD effectively: getting started, and maintaining your momentum

    throughout the project

•   Creating cleaner, more expressive, more sustainable code

•   Using tests to stay relentlessly focused on sustaining quality

•   Understanding how TDD, Mock Objects, and Object-Oriented Design come together

    in the context of a real software development project

•   Using Mock Objects to guide object-oriented designs

•   Succeeding where TDD is difficult: managing complex test data, and testing persistence

    and concurrency

Customer Reviews (13)

Worth the Read!
I've been a TDD programmer for a few years now.I really enjoy the process.But, I was only doing it at the class level.This book as broadened my scope to apply TDD to every layer of the project.Now I do 0 Iterations and work end to end.Those two practices save me a great amount of time and pain just by themselves.

As far as I am concerned this is a must read for modern programmers.It is required reading for anyone I am mentoring.

A must read for all OO developers
This book deserves its place among the most important writings in the TDD and OOD field in the recent years. Its greatest advantage is the presentation of the continuous evolution of high-quality software guided by tests (as the title says it). While reading the third chapter, the audience may clearly see, how Steve Freeman and Nat Pryce really worked on their example project - sometimes making necessary tradeoffs, sometimes taking a step back and so on. From their experience with the example project comes a clear message to the reader about the deep synergy between pragmatic and to-the-point object oriented design and test driven development: if you make good OO analysis and design, your code is more testable - if you drive your code with tests, it will probably also positively influence your design. The authors not only describe this synergy, they also give some very valuable advice about how not to lose it in the long run of your project in the fourth chapter. Last but not least, the authors give a short theoretical introduction about TDD and some hints related to testing corner cases like persistence or concurrency. All in all, I highly recommend this book to anyone interested in Test Driven Development and Object Oriented Design.

Challenge your thoughts on growing your software with tests, constantly
The book "Growing Object-Oriented Software, Guided by Tests" By Steve Freeman and Nat Pryce is packed with so many extremely useful information about writing object-oriented software with tests that I once had to stop reading it as I was afraid I would have gotten a bit carried away. Each and every page has its purpose. Each presented me profound wisdom of Test-Driven Development (TDD) and during the time of its reading I couldn't stop wondering when and how to apply it in my development activities (I still haven't, but am working on it). It's without a doubt a very informatory book about practices and theories behind TDD and jMock. There is no excuse for skipping the book while developing your software as well as software development career itself.

The book consists of 5 parts, 27 chapters, 3 appendixes and almost 350 pages. After 8 informatory chapters of the Part I: "Introduction" and Part II: "The Process of Test-Driven Development", the Part III: "Working Example" appears in which you will learn what it is to write an exceptional book about TDD by its practitioners. It was then when I let myself take some time off reading the book. Following the Part 3's chapters strained every nerve of mine to fully understand the TDD concepts. The authors did a good job of explaining TDD theory focusing on its practical aspects like early feedback, code quality, readability and maintenance.

It's definitely not a book that you read and forget. It is one that you read and never forget. It is one that requires a lot of attention on your part and leaves no stones unturned in pursuing well-thought-out object-oriented software development. The last Part V: "Advanced Topics" was quite hard to follow, perhaps because it touched the concurrency and asynchrony concepts I'm not very good at and interested in. I then enjoyed the Afterword: "A Brief History of Mock Objects" where I learnt the history of jMock in quite a humorous way. Opening each chapter with a motto was highly motivational and made the reading even more enjoyable experience.

I think it'd be better off if the book became a mandatory reading for all who wish to master the art of object-oriented software development.

A unique book
This is one of the best books on TDD, it demonstrates how the TDD process complements OO design, in particular how they work at different levels. There is a big emapahsis on starting the developement process withend-to-end tests (i have not found any other books out there which discusses this), which is demonstrated in the extended worked exmaple.There are lots of nuggets of wisdom in this book, i think even the most experienced developers would find some thing here.
I found the extended worked example most useful, there aren't many books which describes so clearly the developement process, the motivation for each decision is discussed in detail.
Althought the example is in Java, its a must for every developer involved in building OO systems, as it teaches you the process of incrementally designing OO software

Developer collections need this
Steve Freeman and Nat Pryce's GROWING OBJECT-ORIENTED SOFTWARE, GUIDED BY TESTS provides tips to TDD that goes beyond basics to build upon real-world experience. Two TDD pioneers show how to use the tests to develop new software that is reliable and maintainable, from creating cleaner code to using tests to focus on quality and using Mock Objects to guide object-oriented designs. Developer collections need this. ... Read more

Product Description

The Software Insider’s Guide to Getting Hired and Getting to the Top!

Here’s all the information you need to jumpstart your software career: the best ways to get hired, move up, and blaze your way to the top! The software business has radically changed, and this book reveals today’s realities–everything your professors and corporate managers never told you. In his 20 years at IBM as a software architect, senior manager, and lead programmer, Sam Lightstone has briefed dozens of leading companies and universities on careers, new technology, and emerging areas of research. He currently works on one of the world’s largest software development teams and spends a good part of his time recruiting and mentoring software engineers. This book shares all the lessons for success Sam has learned…plus powerful insights from 17 of the industry’s biggest stars. Want to make it big in software? Start right here!

Discover how to

• Get your next job in software development

• Master the nontechnical skills crucial to your success

• “Work the org” to move up rapidly

• Successfully manage your time, projects, and life

• Avoid “killer” mistakes that could destroy your career

• Move up to “medium-shot,” “big-shot,” and finally, “visionary”

• Launch your own winning software company

Exclusive interviews with

Steve Wozniak, Inventor, Apple computer

John Schwarz, CEO, Business Objects

James Gosling, Inventor, Java programming language

Marissa Mayer, Google VP, Search Products and User Experience

Jon Bentley, Author, Programming Pearls

Marc Benioff, CEO and founder, Salesforce.com

Grady Booch, IBM Fellow and co-founder Rational Software

Bjarne Stroustrup, Inventor, C++ programming language

David Vaskevitch, Microsoft CTO

Linus Torvalds, Creator, Linux operating system kernel

Richard Stallman, Founder, Free software movement

Peter Norvig, Google’s Director of Research

Mark Russinovich, Microsoft Fellow and Windows Architect

Tom Malloy, Adobe Chief Software Architect

Diane Greene, Co-founder and past CEO of VMware

Robert Kahn, Co-inventor, the Internet

Ray Tomlinson, Inventor, email

Customer Reviews (15)

Inspiring and informational
I started reading Making it Big in Software a few days ago, and I must admit that I find it hard to stop reading.
Sam managed to write a captivating book on the topic, very inspirational and full of interesting and useful content.

I have been in this industry for over 10 years and I recommend this to (1) anyone thinking of joining, (2) those who have been in it for a while but needs a reminder on what makes this industry great and (3) definitely to those starting out, since this could boost your careers significantly .

The interviews are simply brilliant, I would recommend buying this book just to read those! Sam has managed to leverage them to further prove the points he is making throughout the book.

Very well done!

Great read despite the cheesy title
The title of this book actually turned me off at first; however, I was interested in the interviews so I went ahead and read it.

The main text book is based on the author's years of experience in the industry. Each chapter has an interview attached to it where the author asks the same set of questions to successful people in the software industry.

There isn't anything revolutionary in the book, which is the same for most business success / leadership books that I've read. That shouldn't turn you off though. The author does a good job of stating the facts of how businesses run and how you can navigate within modern software companies. The interviews are interesting and help highlight that there are many paths to success, as well as, many definitions of success.

For some reason I kept getting the moral: Expect to work a lot, and because you'll be working a lot, you'd better enjoy what you are working on. That might just be my particular situation being projected onto the book, but it did seem to be a common theme.

I enjoyed reading the book and have it on my bookshelf now because I'm sure I'll pick it up again. It served as a motivational text and a reminder that I need to be thoughtful with my decisions today in order to help my career tomorrow.

Software engineers and collections catering to them must have this
Making it Big in Software: Get the Job. Work the Org. Become Great is a fine key to obtaining a job in software development. Interviews with Steve Wozniak, plus various to-level CEOs, VPs, programmers, authors, and software architects make for a real-world collection of insights into the industry's process of recruiting and hiring. Software engineers and collections catering to them must have this!

Job skills for geeks
I didn't have great expectations for this book. Since I'm approaching retirement at the end of a mostly academic life, it's a bit late to think about making a professional career in software. But it was cheap enough to consider and expensive enough to bring me up to the "free shipping" point, so I got it anyway.

And it far exceeded my expectations! The chapters cover topics that are relevant to jobs in many areas (dealing with people, leadership, growth, advancement, time management, zen (!), ...). Although similar material is presented in many other books, Lightstone's versions are interesting, original, and spiced with personal anecdotes. Not only will his book will help me to answer students' career advice questions, but I can also tell them to get it.

There is more. The book contains 17 interviews with people who have made signficant contributions to the industry in one way or another. Many of the names are well-known (Wozniak, Stroustrup, Stallman, Torvalds, ...), others less so. But they all have something interesting to say. Every interviewee answers the same questions. This is both good and bad: bad in that the answers occasionally seem a little forced, good in that we get to compare different points of view on specific topics. It's very tempting to peek ahead: what is Wozniak's pet peeve?

If you are starting a career in software, this book will be useful. If you are in mid-career, you will probably pick up a few tips. If, like me, you are near the end, it's fun to compare experiences: been there, done that! Recommended.

The Best career guide I have ever read
This is by far the best career guide I have ever read.

Sam explains things with frankness, humour and entertaining stories. This makes an engrossing read. Each chapter is dedicated to a particular area of career development.. such as networking, innovation or leadership. ( and even starting your own venture)

The interviews from the likes of "the Woz", Torvalds and Gosling really elicited their mindsets and added a perspective you could not find anywhere else.

I've recommended this book to all my friends. Every single one of them agreed that it was a worthwhile read. They all picked up points on how to improve their worklife. In addition they discovered some of the career killers that are self-sabotaging them. The only way to discover these is though a mentor like Sam, who was willing to share his experience through "making it big in software".

5 stars for sure.

... Read more

Product Description
More and more Agile projects are seeking architectural roots as they struggle with complexity and scale - and they're seeking lightweight ways to do it

• Still seeking? In this book the authors help you to find your own path
• Taking cues from Lean development, they can help steer your project toward practices with longstanding track records
• Up-front architecture? Sure. You can deliver an architecture as code that compiles and that concretely guides development without bogging it down in a mass of documents and guesses about the implementation
• Documentation? Even a whiteboard diagram, or a CRC card, is documentation: the goal isn't to avoid documentation, but to document just the right things in just the right amount
• Process? This all works within the frameworks of Scrum, XP, and other Agile approaches
  

Customer Reviews (2)

Must Read for Architects in a Lean Organization.
When I was a C++ programmer in the early 90's Coplien's Advanced C++ Programming Styles and Idioms was a source of interview material when looking for programmers. It's a good bet that this book may fill the same role for those looking to see if candidates for architect roles understand what it means to be an architect in a Lean or Agile Organization. This book dispels the myth that Agile and Architecture don't go together and explains the balance between Agile architecture and too much Big Up Front Design. This book emphasizes the importance of frequent collaboration between stakeholders in defining a good architecture and helps you to understand the importance of architecture to the success of agile projects. With code examples throughout,this book emphasizes that architecture and coding must go together.After describing some general principles of how architecture can add value to an agile project, the authors explain the Data Context, Interaction (DCI) architecture, which provides an framework for building lean architectures.My one minor complaint is that the transition between the general discussions of lean architecture and the focused discussion of DCI was a bit abrupt. But this was a minor distraction from an enjoyable and informative read. Rich with citations, places to go for more information, and historical context, this book will be useful for anyone who is struggling with how to build systems that need to support complicated user interactions (which could describe most non-trivial systems).

A must read for all system developers
This is a different book. Where most books expound a single theme such as Agile, Lean, or Scrum, "Lean Architecture for Agile Software Development" paints on a much broader canvas: Working with the end user, end user's mental model, user requirements, system architecture, and right down to actual code.

This is neither a beginner's "how to do it in ten easy lessons" nor is it a design method. It is a book written for the mature professional by two authors whose long experience has given them a deep understanding of what really matters in practical programming.

At a first glance, many methodologies appear as mere fads, but Coplien and Bjørnvig see through the fads and build on their real worth to create a thought-provoking and eminently practical book.

Three random jottings from my first reading:

* Architecture: "No matter how we care to define it, software architecture should support the enterprise value stream even to the extent that the source code itself should reflect the end user's mental model of the world."

* Lean secret: "...unite specialists together in one room: everybody, all together, from early on."

* Form and functionality: "System architecture should reflect the end user's mental model of the world. The model has two parts: The first part relates to the user's thought process when viewing the screen, and to what the system is: its form. The second part relates to what end users do - interacting with the system - and how the system should respond to user input. This is the system functionality. We work with users to elicit and develop these models and to capture them in code as early as possible."

The authors claim that an end user should have a picture in his head that enables him to see the commands that are meaningful in a given situation and to understand what they will do for him. This picture, Jim calls it the end user's mental model, it will be reflected into the actual code in well-built systems.

A few years ago, this reviewer introduced a new programming paradigm that he called Data, Context, and Interaction (DCI). The main feature of this paradigm is that it splits the code into two distinct parts. One part specifies system state; the other part specifies system behavior. Coplien and Bjørnvig use this paradigm to fill in the gap between architecture and code execution. To quote from the book:

* Key building blocks of object-oriented design: "Objects, which are end users' conceptualization of things in their business world; Classes, which provide simple, encapsulated access to the data that represents business information; Roles, which interact in a use case to achieve some business goal."

This book is a MUST read for all who want to understand the true nature of systems development. ... Read more

Product Description

Software Systems Architecture is a practitioner-oriented guide to designing and implementing effective architectures for information systems. It is both a readily accessible introduction to software architecture and an invaluable handbook of well-established best practices. It shows why the role of the architect is central to any successful information-systems development project, and, by presenting a set of architectural viewpoints and perspectives, provides specific direction for improving your own and your organization's approach to software systems architecture.

With this book you will learn how to

• Design an architecture that reflects and balances the different needs of its stakeholders
• Communicate the architecture to stakeholders and demonstrate that it has met their requirements
• Focus on architecturally significant aspects of design, including frequently overlooked areas such as performance,resilience, and location
• Use scenarios and patterns to drive the creation and validation of your architecture
• Document your architecture as a set of related views
• Use perspectives to ensure that your architecture exhibits important qualities such as performance, scalability, and security

The architectural viewpoints and perspectives presented in the book also provide a valuable long-term reference source for new and experienced architects alike.

Whether you are an aspiring or practicing software architect, you will find yourself referring repeatedly to the practical advice in this book throughout the lifecycle of your projects.

A supporting Web site containing further information can be found at www.viewpoints-and-perspectives.info

Customer Reviews (21)

THE book on software architecture
I'm impressed. Rarely do the IT related books are written so concisely and clearly but at the same time providing extensive coverage of the subjects. I will surely keep it on my desk for future reference when working on different software projects.

Pragmatic Software Architecture
As the title indicates this book is one on software architecture. What sets it apart from many books in that area is that it presents a pragmatic approach to architecture. The basic premise introduced is splitting the architecture into different views, which each address a specific set of concerns, such as information, concurrency, deployment, development etc. The concept of views is not a new one, however what the authors introduce is the concept of viewpoint which is the concrete representation of the view through templates, and artifacts. These artifacts include questions and checkpoints one should go through to describe the architecture.

The above view and viewpoints cover more or less the functional requirements. Perspectives on the other hand cover the quality attributes such as availability, scalability, usability etc. The authors then show how perspectives and viewpoints work together to represent the overall architecture. This includes showing the areas of overlap of these viewpoints/perspectives and how they are to be addressed.The book is supplemented with materials (templates, cheat sheets, questionnaires) on the following website:[...].

This is a great software architecture reference and one that you will keep on your desk to refer to on an ongoing basis, particularly because of its pragmatic approach. A must read for any software architect. It will also help developers anticipate the questions that will be asked during an architectural review, and things to consider throughout the life-cycle of a software project.

Review
I bought this book for my Software System Architecture Class..Book has good examples and explanation is very clear and understandable..Hope it works for me in future..:)

The Missing Manual for Software Architecture
I was lent this book by a mentor and very soon realised this was something I had to have my own copy of as it brought together many aspects of the software architect's job which I had not seen covered so well before.It is easy to read and understand, which belies the underlying complexity of the material and is a testament to the skills of the authors.Not only is the content itself good but I have also found the guided bibliography invaluable.

excellent book
This book is much better than I expected.It is practical and very informative, with good, simple examples to reinforce the points made.It covers pretty much everything you will need to consider when designing or evaluating a large IT system.This book is not outdated either.It is as useful today as when it first went to print.I highly recommend it. ... Read more

Product Description
Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.

Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer—but only if you work at it.

What kind of work will you be doing? You’ll be reading code—lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.

Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code—of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.

Readers will come away from this book understanding

• How to tell the difference between good and bad code
• How to write good code and how to transform bad code into good code
• How to create good names, good functions, good objects, and good classes
• How to format code for maximum readability
• How to implement complete error handling without obscuring code logic
• How to unit test and practice test-driven development

Customer Reviews (76)

a Must read!
This book has a deep impact on how I write or even think about code. I you care about your craft you should really read this!

A must read!Fantastic!
This is a fantastic book about writing clean code and test driven development.Robert dedicated an entire chapter, 14, to refactoring code and included why he refactored the way he did.Thats not all, the way Robert wrote this book is from one coder to another meaning you are his audience; very refreshing.He doesn't hold your hand, but gives you enough information to get you literally on the same page as him with every line.The patterns and "smell tests" included here are worth the cost of this book alone.

This book got me passionate about coding again and about unit testing.If you are a programmer, it doesn't matter what language, (I write python mostly) this book deserves a place on your bookshelf.

Complete Awesomeness
Given the Author is Uncle Bob Martin, I have to admit that I had very high expectations for this book and they were exceeded.Uncle Bob Martin's writing style will keep you engaged and eager to read on.This book will help arm you in tuning your craft as a software developer striving for clean and beautiful code.

If your not sure how good your code is read this!
I have been a Java programmer for a couple of years now and while I know I have a good appreciation for OO concepts and their application I wasn't sure whether my code was actually very good - from the perspective of being efficient, easy to read, extendable, manageable etc. This book, written by seasoned, well-respected programmers gave me confidence in some of things I had already being doing, but mostly helped me improve alot of things and learn't quite a few tips for things I wasn't doing in my code.

Not too thick, very readable - I rarely recommend books to colleagues since I find its a bit subjective, but this is probably the 1 programming book that I have read so far that I always recommend.

You won't be sorry you read it, even if you don't learn anything you will perhaps gain confidence in what you are doing.

A book about how to produce quality code
One of the best books I've read about how to design and produce quality code. Being a professional software developer/craftsman is more than just being able to solve hard technical problems (among other things). It's being able to solve them with elegance and style, and this book helps you develop the knowledge and skills to do just that.

... Read more

Product Description
Building on their breakthrough bestsellers Lean Software Development and Implementing Lean Software Development, Mary and Tom Poppendieck’s latest book shows software leaders and team members exactly how to drive high-value change throughout a software organization—and make it stick. They go far beyond generic implementation guidelines, demonstrating exactly how to make lean work in real projects, environments, and companies.

The Poppendiecks organize this book around the crucial concept of frames, the unspoken mental constructs that shape our perspectives and control our behavior in ways we rarely notice. For software leaders and team members, some frames lead to long-term failure, while others offer a strong foundation for success. Drawing on decades of experience, the authors present twenty-four frames that offer a coherent, complete framework for leading lean software development. You’ll discover powerful new ways to act as competency leader, product champion, improvement mentor, front-line leader, and even visionary.

• Systems thinking: focusing on customers, bringing predictability to demand, and revamping policies that cause inefficiency
• Technical excellence: implementing low-dependency architectures, TDD, and evolutionary development processes, and promoting deeper developer expertise
• Reliable delivery: managing your biggest risks more effectively, and optimizing both workflow and schedules
• Relentless improvement: seeing problems, solving problems, sharing the knowledge
• Great people: finding and growing professionals with purpose, passion, persistence, and pride
• Aligned leaders: getting your entire leadership team on the same page

Customer Reviews (4)

Not As Satisfying But Still Worthwhile
Anything by Mary and Tom Poppendieck is recommended reading but I'm not quite as impressed this time around. To be sure, there is much we can learn here about the application of lean principles to project management and software development. The discussion of value demand vs. failure demand is particularly good. And I couldn't agree more with their assessment of targets and "goals gone wild." Our systems, as well as our people, are what they are; targets will not change their capabilities. We're more likely to produce distortion and cheating than improvement. And "relative goals can motivate competitors to sabotage each other's performance. Thus ranking performance relative to peers can be damaging...if reward systems are based on this ranking." Performance rewards should be "shared equally among all competitors." A number of themes span multiple frames--a weakness of the "frames" construct--and the authors revisit this one several times.

More lessons from Toyota--the darling of every lean study--are helpful even if quotes such as this one now ring hollow: "One of the fundamental elements of TPS [the Toyota Production System] that management must be fully committed to is the `customer first' philosophy."

Frame 6: Quality by Construction is generally helpful but this is where I first began to notice some incendiary rhetoric and straw-man argumentation against waterfall or "sequential" development. For example: "not trying to find [defects] until the end of development" demonstrates "the distorted logic of the sequential frame of reference." Later, in telling the fascinating story of the Empire State Building's construction: "They did not break down the job into tasks" and the project "was not framed by cost, schedule, and scope." Yet they did break down the job into "small batches" and the project was framed by a number of constraints including "$35 million of capital...and May 1, 1931." And "Let's be honest; customers do not need scope. They need to have business goals accomplished"--the definition of scope. And "I often wonder how companies can expect superior performance...when there is no one whose job it is to uncover the strengths of each person and match the job to the individual."

Some concepts advocated here, such as eliminating defects, change control, and work queues, are debatable and sometimes raise more questions than answers. On quality, for instance, the authors quote Edsger Dijkstra who says "effective programmers...should not waste their time debugging--they should not introduce bugs to start with." Bug-free programming is certainly possible but at what cost, even in a lean environment? And on eliminating work queues: "'But,' you protest, `our customers won't tolerate that!' Or `How will we learn what customers want if we turn down their requests?' Or `How will we keep track of what has been discarded?' Or `Won't customers simply keep their own queue?' Or `What do we do with the list we have now?' These are all good questions, and you should search for good answers." Such conclusions are not quite satisfactory. Nonetheless, this work will certainly force you to think and is, therefore, recommended reading.

Great book to read after you have some practical experience with Agile.
After more than a year of leading agile team, I finally found a book that contains discussions of many of the issues that bother me.

A top pick for any software programming collection
Mary and Tom Poppendieck's Leading Lean Software Development builds on prior best-selling titles LEAN SOFTWARE DEVELOPMENT and IMPLEMENTING LEAN SOFTWARE DEVELOPMENT to show how to drive high-value change throughout a software organization. From focusing on customers and implementing low-dependency architectures to managing big risks and optimizing workflow and schedules, this is a top pick for any software programming collection.

lean - by frames of reference
Wow!I was blown away by how good it was.I expected it to be "light reading" as I'd read about many of the concepts elsewhere.Somehow the authors managed to present them all in a thought provoking way.Even the introduction had me scribbling in the margins.As a result, I only finished 5 chapters in a 6 hour flight.I promptly finished the remainder the next morning.A real page turner.

Each of the chapters follow the same format: detailed example of company applying concepts, 4 frames and brief portrait of how used.A frame is a point of view - like a camera frame.There were detailed examples throughout.Each chapter ends with questions to think about - these aren't classroom exercises - they really help.The frames really drew me in - each time I started the next one, I felt the mental shift.

I'm not sure what my favorite part of the book was - between the current examples (banking crisis, Captain Sully, Obama's website), historical ones (Empire State Building construction), clear diagrams, etc.

The beginning of the book really grabbed me.It explained why Southwest Airlines is so much more successful than the traditional airlines.The fact that I was on an airplane at the time helped, but the example stood on its own.

The fact that I didn't go more than 5 pages without writing a note or more than 1-2 pages without underlining something really speaks for itself.The book was great! ... Read more

Product Description

Customer Reviews (22)

Some nuggets, but no so good
There are some very interesting nuggets in there, but as others have mentioned, most of them are simple common sense or of no use at all.
I bought it mostly because of the good reviews, however I'm quite disappointed with the book.

Interesting wisdom from experts
I thought this was an interesting book, which provides insight from a group of experts on a variety of software development issues.Every two pages, a software architect discusses essentially what they feel is required to be a successful architect.These topics cover everything from understanding hardware, keeping your coding skills up, to being able to speak intelligently with management.

My only complaint is that I would have preferred 97 different experts.Rather, many of the contributors are included multiple times throughout the book.While it would have been nice to get the perspective from many more different sources, this is still a valuable and interesting book.

I didn't finish
(The following won't be completely fair because I feel unable to write a book such this one)
Although I was interested about the subject I felt bored after reading the first few pages. Each chapter seemed a repetition of the others. So, I suppose that I expected something either more personal (e.g. kind of war stories) or more technical (i.e. how to document such and such)... something like "coders at work" or "beautiful code", or something like "Elements of programming"...

I will try to read it again in a few months. All the books deserve a second chance.

97 Valuable Discussion Points
If you buy this book expecting 97 in depth dissertations on software architecture & design, you will be disappointed.It is instead, a collection of observations on the relationships between business, people and technology.This is not a tome that one sits down and reads in a day, acquiring all of the knowledge of the collected contributors in that instant.It is instead a book, which is best read a chapter or two at a time, and discussed amongst your colleagues.Some lessons you will be able to implement immediately, some will not be of value to you ever.Many deal with issues that (as one would expect) will help to make your life easier if implemented in the planning stages of a project.The only thing I would change so far would be to change "Your Customer Is Not Your Customer" to "Your Customer Is Not Your Only Customer" or "Everyone Is A Customer".

I give it 4 stars instead of 5 because as others have noted, it is very lightweight.I do feel that this book would be suitable for most folks in technology to read, not limited to software architects.I would have no hesitation recommending this book to everyone from a Junior Systems Administrator or Project Manager all the way to a Director Of Technology.

incoherent and useless
Why does a famous (and, he has proven it, excellent) technical writer dare to compile
such a useless, incoherent and impractical amount of pseudo-advice?

His other books provided deep technical knowledge and practical help.

This one's not worth its price - there are much better books available...

alternatives: Taylor et al: Software Architecture (Foundations, Theory and Practice): Great read.
Bass et. al: Software Architecture in Practice: Great read.
Buschmann et. al: Pattern-oriented Software Architecture: Great series.
Fowler: Patterns of Enterprise Application Architecture: Great, highly practical...

So - don't bother with this one, go get a good book :-)

... Read more

Product Description
Spolsky is knowledgeable, funny and free of unnecessary religious fervor. Joel on Software is a must-read....having (Joel on Software) in one place, edited, with an index, is probably the best twenty-five dollars you'll spend this year.

— Greg Wilson, Dr.(Joel Spolsky's) genuine desire to make the software world a better place keeps us coming back for more.

— Bruce Hadley, softwareCEO.This book will challenge, encourage, upset, and entertain you.Spolsky knows his stuff, and he's got the war wounds to prove it.This book is worth the price of admission...

— Tom Duff, Duffbert's Random Musings

An entertaining oportunity to get to know one of today's most influential developer/authors.Spolsky based these observations on years of personal experience.

The result just a handful of years later? Spolsky's technical knowledge, caustic wit, and extraordinary writing skills have earned him status as a programming guru! His blog has become renowned throughout the programming world&emdash;now linked to more than six hundred websites and translated into over thirty languages.

Joel on Software covers every conceivable aspect of software programming&emdash;from the best way to write code, to the best way to design an office in which to write code! All programmers, all people who want to enhance their knowledge of programmers, and all who are trying to manage programmers will surely relate to Joel's musings. ... Read more

Customer Reviews (57)

Awesome Book !!
Personally, after reading this book, I think this guy is a genius !! You might find this a book with attitude, but you know what...it is more that justified with the compelling arguments Joel provides.
Loved the chapters "The Laws of leaky abstraction" & "The Iceberg secret revealed".
Overall, an awesome read for just about anyone involved in a software project from developers to project managers.

almost funny; must for any software entrepreneur
Joel is doing an excellent job in presenting his arguments. He's funny (in most cases) elegant and you can find yourself saying: mmmm, he has a point.

You don't need to read it cover to conver, though I really recommend doing so. My favorite chapters:

Strategy Letter II - that is the Chicken and the Egg problem.

"no body is going to buy your platform until there's good software that runs on it and nobody is going to write software until you have a big installed based"

Big Macs Vs. the naked chef

and of course a MUST READ: Strategy Letter I: Ben & JERRY's VS AMAZON. WOW

...Anyway, what are you waiting for - go get it!
Dror Guzman

Fantastic. Informative and witty.
Excellent read. Funny enough to keep you reading, and informative as well. Very great concepts and unique thinking. Highly recommended.

something all programmers,managers and people who love programmers should read
What a great book! Every programmer and manager should read Joel - even if you don't agree with him, he brings up tons of points you just cannot ignore. For instance, one of my pet peeves is lack of up front planning. And when I say lack, I mean none. The amount of pain this has caused me in the past is impossible to measure (and there is a reason I'm reasonable good with time estimations - I plan what I can up front). Reading him talk about the lack of planning in software dev really warmed my heart.

Another nice little piece was his talk on strings at the beginning. As an embedded engineer I know first hand how costly string manipulations are. I tend to forget that not everyone knows this. Its good to see a mainstream programming book take this topic on.

I will also admit to loving his support of Microsoft; I also feel that they get short shifted and for similar reasons (they really did bring computing to the masses). Finally Joel nails the differences between Microsoft programmers and Linux programmers - to a T. The general breakdown is MS programmers design the GUI first and add the CLI later while the Linux folks do the opposite. In general, this makes a lot of sense, especially when you compare Linux and Windows from about 2 yrs ago. Or Gnome today (KDE ftw).

If you program, or love someone who does, read this book.

Smart
Joel is a very smart guy, period.
If you are programmer and do not have time to read cover to cover, just finish these two essays:

- GETTING THINGS DONE WHEN YOU'RE ONLY A GRUNT
- THE GUERILLA GUIDE TO INTERVIEWING

This is Joel's criteria for hiring the right people:

In principle, it's simple. You're looking for people who are

Smart
Get things done

In Joel's defination, smart is right aptitude not particular skill set.
(mind you, Joel also said understanding c pointers is an aptitude not skill, and he discounts brain teaser as a valuable means to test smartness)

If you have more time, read INCENTIVE PAY CONSIDERED HARMFUL for amusement.
... Read more

Product Description
Software architecture is foundational to the development of large, practical software-intensive applications. This brand-new text covers all facets of software architecture and how it serves as the intellectual centerpiece of software development and evolution. Critically, this text focuses on supporting creation of real implemented systems. Hence the text details not only modeling techniques, but design, implementation, deployment, and system adaptation -- as well as a host of other topics -- putting the elements in context and comparing and contrasting them with one another. Rather than focusing on one method, notation, tool, or process, this new text/reference widely surveys software architecture techniques, enabling the instructor and practitioner to choose the right tool for the job at hand. Software Architecture is intended for upper-division undergraduate and graduate courses in software architecture, software design, component-based software engineering, and distributed systems; the text may also be used in introductory as well as advanced software engineering courses. ... Read more

Customer Reviews (7)

Foundations, Theory,Practice is the order of book priorities
When I first contemplated to buy this book I thought it might be slightly... academic... After buying it... my a priori thinking proved to be somehow true... The material is solid with many valuable comments, some of which I always had in the back of my mind, but never done the final steps to "materialize" them.For instance the fact that architecture is very close to design to the point that sometimes is difficult to distinguish the two. In this sense I enjoyed the introductory chapters with general ideas. When it comes to main content I was a bit surprised by the emphasis on classifications: views, models, implementations ... the part which I thought has an academic flavour.

Modern intro to Software Architecture
I bought this book from Amazon late 2009, it has not left my side since. This book provides a modern introduction to the field of software architecture, for both students and seasoned professionals. Certainly a must if you are working in this field or aspiring to.

FYI the course slides are available from the book's website [...]

Worth the money to find out more about architecture
Excellent academic treatment of all things architecture. I've gone through just over half of this textbook. This book is good enough that I have decided to finish the rest of the content. The only reason I give it 4 stars instead of 5 is because the authors do not present real world examples of architecture. In retrospect, I have decided to give this book 5 stars, because real world examples of architecture are either competition sensitive or precluded from being revealed due to security considerations. The authors really should have found an IT shop or shops willing to reveal a number of best practice architectures, so that those interested could get a feel for how complex and interconnected best practice architectures are.

This is an excellent textbook for students, and for those IT professionals who want to learn more about the architecture specialization, it is a good reference with an impressive continuity and it is very well organized in its introduction of all of the relevant concepts.

Software Architecture text - not worth
I do not recommend this book for practitioners or as a college text

This book needs serious review and editing by decent english readers for repetition, grammer, and consistency. This book is too hasty even in defining the basic term architecture. It is quite hard to read and frustrating because of inconsitencies. Some bogus, artificial, presentations pervades the book.

Repetition are OK if they are consistent, however repeated topic contracdicts the previous discussions. The flow of sentences are too hasty even for experienced architects.

Topics are identified in a fashion that, if authors had not rushed it could have been a better book. If the same topics were presented in more concise format, this book could be lot thinner and easier to read; in addtion font used is too small, figures are not simple sketches, english is too interwinded (not simple but seems too artificial) makes it difficult to adopt the book. Some examples are good but incomplete.

A fine introduction to the discipline of software architecture
Software Architecture: Foundations, Theory, and Practice is a landmark text that will become an essental introduction to the discipline of software systems architecture. If you are a student, tester, manager, methodologist, developer, or simply an architect, and want a holistic understanding of what real software architects think software architecture is and why it matters, this is the place to start.

I bought this after Roy Fielding (of REST and HTTP fame) mentioned it on the rest-discuss mailing list. Roy is one of the industry's top architects, and I wasn't disappointed. The book is timely - architecture is coming to be accepted as an important activity, especially for distributed, and large scale systems. What many people don't realize is that drawing pictures, writing documents no-one reads, meta-modeling, and pontificating on "concerns" are not software architecture. Software architecture is about introducing constraints via principled, objective design to achieve particular system properties. Architecture is difficult and exhausting work, but done well can offer immense value to users and stakeholders. This book, along with Rozanski and Woods' "Software Systems Architecture: Working With Stakeholders Using Viewpoints and Perspectives" makes that explicit.

The book is unapologetic about software architecture's standing in the industry. SAFTAP positions architecture as the primary design activity for software - not development, not requirements analysis, not testing, not methodology, but architecture. That will make for interesting debate.

My single criticism of this book is that it does not do enough to treat user experience (Ux) and informatics as architecturally significant, but not enough to take away a star. I'm hoping a future edition will rectify that.

Some noteworthy chapters in the book (there are 17 chapters in all):

* The Big Idea: explains what architecture is and why it matters. The building metaphor (often heavily criticised in the industry, see the excellent "Software is not Bricks" by Raganwald) is dealt with calmly and then put to one side.

* Architecture in Context: explains how architecture fits into the overall lifecycle and process of software systems.

* Connectors: this is one of my favourite chapters. The concept of a connector is vital to a software system, but is rarely if ever discussed in programming or engineering texts.

* Modeling: probably not what you think. This chapter emphasizes communication, clarity and disambiguation over notations and diagrams.

* Implementation: programmers hate the quip "implementation detail", but in truth many things in a system are just that and it does not mean they are unimportant. This chapter covers those details and why they matter.

* Deployment and Mobility: good architects understand that a systems have a life well beyond initial delivery, which is where most developers, managers and stakeholders tend to focus attention. This was one of favorite sections as the running system simply doesn't get enough attention in most projects today.

* Applied architecture and Styles: covers some examples of architectural styles, notably REST and SOA, which are certainly the best known architectures in my part of the industry.

* Designing for non-functional properties: many non-functional concerns don't start to matter until the system is deployed and there isn't always agreement among technical specialists over what's truly important. If you are technical specialist this should help you articulate the cost/benefit of looking at the "unfeatures" of a system.

* Security and Trust: software is increasingly distributed, and increasingly a super-system of components interacting over the Internet and Mobile Networks. So it's good to see a text that makes security a first order concern and not just a non-functional ones.

* Domain Specific Software Engineering: I'm trained as an industrial designer where the notion of common modular components with standard interfaces acting as a platform for product development is a known Good Thing in domains such as the automotive and consumer electronics industries. This chapter gives a good overview of modular design focusing on the software product lines approach. The example given is from Philips, but it could as easily have been from Toyota.

* People, Roles and Teams: software architecture, like other architecture disciplines, has a strong social dimension. This chapter explains how the architect role fits into an organisation and where they can add value and exert influence. ... Read more

Product Description
The author of the classics "Code Complete" and "Rapid Development" throws a lifeline to the industry's huge and indispensable population of rookie managers and technical leads. This book is a roadmap to how an effective software project works--understandable even for those with limited project experience. ... Read more

Customer Reviews (64)

Software Project Survival Guide
This book was initially loaned to me by my IT specialist when I came to him with problems I was having with a software product whose development I was overseeing. I wish I'd read it at the very start of the project---it would have saved me much anguish.

I've read this book a long time ago, but the remembering is good
I've read this book several years ago, in 1998, I think. It was my first glimpse on software project planning. At the time, I was a bit confusing, the book has a lot of examples of very big projects. But the best practicesit provides are useful until today.

Don't know if it's a good book nowadays, but it's definitely a book I won't forget.

A must for project leaders
The book presents an analysis about the project management in a very practical way.

In it, Steve demystifies that in a project the "well" and "fast" are in opposite sides. By contrast, him tells us that for do it fast and cheap, it is essential to do it well.

A project leader should have it in his desk.

well-researched
I'm a one-man database development shop at a nonprofit with a shoestring budget.Without the benefit of senior level programmers, I've had to learn most of my software engineering lessons the hard way- by experience.

I picked up this book seven years into the job, which in retrospect was about seven years too late.In some respects, this book repeats lessons that that have already become obvious through experience (e.g., software testing needs to be performed separately from development).But, this lends credibility to my judgment, and provides new insights substantiated by software engineering research studies.Non-technical management and funders are responsive to the hard figures I often find myself citing from this book.For example:

1) Programmers are 2.5 times more productive in a quiet office vs. a cubicle- so, I need to be allowed to work from home

2) The most efficient programmers are 10 times more productive than the least efficient programmers- really, you would think this would be obvious, but when work needs to be contracted, the low bidder is not necessarily the best choice over the long haul

Currently faced with my most substantial and challenging programming project yet, I'm essentially using this book as a cookbook to process.Upfront I was a bit overwhelmed with the scope of the project.Having finished the book, I have a well-defined process in place, am confident this will get done, and feel I am much more articulate describing the stages of software development to management and contracted vendors.Some presumably industry-standard strategies are proving invaluable- implementing a Top Ten Risk list to ensure that major barriers are addressed upfront rather than deferred, creating specific milestones, etc.

This book (or an equivalent) should absolutely be mandatory for anyone about to take on their first major software project.It is most useful because it reads like a cookbook- guiding you through all the phases of software development, one after the other.

The presented methodology is good but...
will the book be convincing enough for you to adopt it?

I have not found this book very fun to read because of its very structured and academic format. I have not learned much from it as much of its content is general wisdom that anyone with many years of experience in the industry has probably seen around before. Something positive I can say about the book is that I totally adhere to the methodology explained in the book. In my software development career, I have experienced myself the benefits of applying similar software development management methodology and I have also seen the negative consequences of not following it. ... Read more

Product Description

"This remarkable book combines practical advice, ready-to-use techniques, anda deep understanding of why this is the right way to develop software. I haveseen software teams transformed by the ideas in this book."

--Mike Cohn, author of Agile Estimating and Planning

"As a lean practitioner myself, I have loved and used their first book for years.When this second book came out, I was delighted that it was even better. If youare interested in how lean principles can be useful for software developmentorganizations, this is the book you are looking for. The Poppendiecks offer abeautiful blend of history, theory, and practice."

--Alan Shalloway, coauthor of Design Patterns Explained

"I've enjoyed reading the book very much. I feel it might even be better than thefirst lean book by Tom and Mary, while that one was already exceptionallygood! Mary especially has a lot of knowledge related to lean techniques inproduct development and manufacturing. It's rare that these techniques areactually translated to software. This is something no other book does well(except their first book)."

--Bas Vodde

"The new book by Mary and Tom Poppendieck provides a well-written andcomprehensive introduction to lean principles and selected practices for softwaremanagers and engineers. It illustrates the application of the values andpractices with well-suited success stories. I enjoyed reading it."

--Roman Pichler

"In Implementing Lean Software Development, the Poppendiecks explore moredeeply the themes they introduced in Lean Software Development. They beginwith a compelling history of lean thinking, then move to key areas such asvalue, waste, and people. Each chapter includes exercises to help you apply keypoints. If you want a better understanding of how lean ideas can work withsoftware, this book is for you."

--Bill Wake, independent consultant

In 2003, Mary and Tom Poppendieck's Lean Software Development introduced breakthrough development techniques that leverage Lean principles to deliver unprecedented agility and value. Now their widely anticipated sequel and companion guide shows exactly how to implement Lean software development, hands-on.

This new book draws on the Poppendiecks' unparalleled experience helping development organizations optimize the entire software value stream. You'll discover the right questions to ask, the key issues to focus on, and techniques proven to work. The authors present case studies from leading-edge software organizations, and offer practical exercises for jumpstarting your own Lean initiatives.

• Managing to extend, nourish, and leverage agile practices
• Building true development teams, not just groups
• Driving quality through rapid feedback and detailed discipline
• Making decisions Just-in-Time, but no later
• Delivering fast: How PatientKeeper delivers 45 rock-solid releases per year
• Making tradeoffs that really satisfy customers

Customer Reviews (18)

You MUST OWN this book if you manage software
Whether you build software for internal use only, or, as I do, you build and maintain commercial software for businesses and government .,. you have to read this book.

First, this book is for management ... especially those who manage the managers who manage project leads, product managers and line of business management ... this is a MUST READ for anyone who pays for software, invests in software, thinks about software or maintains software.

While I am well-steeeped in the agile methods of Scrum, this is an excellent text that builds on a long body of knowledge and experience.

I used the concepts in this and a few other learned books and experts to reduce the costs of supporting some $70 million worth of software business from $12M to $6M!!!Quality improved, employee satisfaction soared.Customers were appreciative.

I use a yellow highlighter when I read books I learn from.This books was YELLOW when I finished .. and I have purchased over a dozen copies for colleagues who manage software.

A must have for your library!!!

Great overview of lean concepts
A good overview of lean, it draws on a lot of manufacturing analogies. If you don't have a development or technology background I think this helps drive home the points of lean well. But if you do have a technology background you might find yourself wanting more details of how development groups have implemented it.

A principle-based approach
The seven principles of Lean Software Development are; Eliminate Waste, Build Quality In, Create Knowledge, Defer Commitment, Deliver Fast, Respect People and Optimize the Whole.Each of these principles is discussed in detail.The theoretical foundations are supplemented by real-world examples, case studies and experience reports.Each section ends with a list of concrete exercises called "Try This", which invites you to put your knowledge into practice.This book is an excellent way for agile leaders focus on the most significant factors for success.

Inspiring and Fat Free
Some of this is so counter-intuitive. But once I began reading, I could see waste in software development where before I had seen good process. Just the concept of unfinished software as Inventory has caused me to rethink my previous willingness (even eagerness) to accommodate context switches between different projects. If the project being switched from has not issued a new iteration of the software, then there is wasted functionality that might have been providing value to users if it had been finished, just sitting on a "shelf" gathering dust. And the further cost of getting back up to speed on that project to transform partly finished work into deliverable software.

I would like to recommend also these other two lean books Lean Thinking : Banish Waste and Create Wealth in Your Corporation, Revised and Updated and The Machine That Changed the World: The Story of Lean Production-- Toyota's Secret Weapon in the Global Car Wars That Is Now Revolutionizing World Industry which go into the research and rational behind the concepts in this book. It will sort out your doubts.

I found myself reading this book during coffee breaks. It's a great read.

Gets to the heart of agile, not just the trappings
I'm very impressed with this book.Unlike most Agile books (that focus on the decorations of the process), this gem dives right into the principles of the process.I especially like how the authors go back to proven manufacturing models to show that software development is engineering and not science.I've read a ton of Agile books, but find every myself continually delighted as I turn each page.This is the first Agile book that I think someone completely new to Agile could use to bootstrap the process into their own organization (but still would recommend a consultant).

Highly recommended for both experts and novices. ... Read more