Product Description
Intended for a sophomore/junior level course in software engineering.

The ninth edition of Software Engineering presents a broad perspective of software engineering, focusing on the processes and techniques fundamental to the creation of reliable, software systems. Increased coverage of agile methods and software reuse, along with coverage of 'traditional' plan-driven software engineering, gives readers the most up-to-date view of the field currently available. Practical case studies, a full set of easy-to-access supplements, and extensive web resources make teaching the course easier than ever.

The book is now structured into four parts:

1: Introduction to Software Engineering
2: Dependability and Security
3: Advanced Software Engineering
4: Software Engineering Management ... Read more

Customer Reviews (1)

A valuable resource
Any book in its ninth edition has already proven its place to its audience - Sommerville's text has earned its reputation as a standard in the field. This book's twenty-six chapters cover four major topics: introductory material, dependability and security, advanced software techniques, and project management.The first section include basic life cycle phases of requirements, modeling, architecture, implementation, testing, and ongoing support, along with smattering of the social processes in which these activities take place.

Advanced topics, the third section, include modern topics such as aspect-oriented programming (AOP), component systems, and embedded applications. AOP seems to be moving in from the fringes of software development (Aspect-Oriented Programming with the e Verification Language gives lots of good reasons for that, despite being tangential to normal software). Still, object orientation dominates current practice by a wide margin and gets only minor mention, so I find the emphasis misplaced. Likewise, the embedded section under-represents the 99% of all processors that don't run Windows or Linux, i.e., the ones in your microwave, digital watch, CD player, car air bags, sewing machine and cell phone. Still, mentioning it at all puts this ahead of many comparable texts.

So does the second section, on dependability and security. As computers become more pervasive and take on more life-critical applications, these issues only grow in importance. As with other sections, however, topics that represent many people's entire careers get only 20 or 30 pages here. A book of this breadth necessarily sacrifices depth, however, so I can't complain too loudly. Likewise, the section on project management issues could be a book of its own, like Braude's Software Engineering: An Object-Oriented Perspective.

Real discussion of this book's content would take more space than I have here, and would soon get into matters that depend on specific applications or on personal opinion and experience. I found one pervasive weakness in this book, however, a weakness shared by every other software development and engineering text I've seen. Standards and regulatory requirements get only scant mention. In the real world, software design and implementation happens in a complex environment of interlocking standards that affect nearly every aspect of software design and implementation. I applaud Sommerville for mentioning Sorbanes-Oxley (despite the book's international audience). Still, the hundreds of applicable standards from the IEEE, ECMA, ISO, ITU, NIST, and dozens of other organizations warrant a chapter of their own. I look forward to seeing that chapter, in this book if not in some other.

- wiredweird


PS: I'm wrong a lot, but that cover photo could credibly be MIT's Stata center under construction. If so, in restrospect now that it's completed, that wouldn't be the most uplifting choice of engineering images. ... Read more

Product Description
Software engineering leads to better software products. This book teaches readers how to develop games according to a design and follow a standardized approach to game development. It provides a multitude of exercises that show just how software engineering practices can improve your game. All the basic categories of software engineering are covered. Programmers, designers, architects, generalists, software engineers, and game developers seeking knowledge about standard frameworks for games and their relative merits will find this text more than satisfying. Three frameworks (function, object-oriented, and patterned) are presented, contrasted, and fully described through design documents. ... Read more

Customer Reviews (5)

Good deal
I am totally happy with this text. Other students in the course purchased it through the school bookstore and they are missing an entire chapter. Arrived in good condition. Took a little longer than I had hoped, but given that everything including CD and all chapters were present... =)

Excellent, Professional, Formal Engineering Approach to Games!
The author takes all of the traditional software engineering principles and practises and provides logical, practical examples of their application within the domain of commercial game development.Not an easy task but one at which the Author excels.

Academia or anyone involved in games and/or software engineering should have this book as a reference text.

Excellent work.

Exactly what I expected
I got exactly what I expected, the book was new and showed up within the expected time frame.

Nice book for beginners
I like the fact that the author got out of his way to actually create a game to illustrate the software engineering methodology. Also, all the code and documents of the game are on the CD.

The only CON I would give to this book is that it keeps referring to things that have not been explained. So, if you are on Ch. 1 you have to quickly go and read a section on Ch. 3 to understand what the author is saying on Ch. 1 (Obviously Ch. 1 is an introduction to the whole book and it is supposed to talk about everything. This is just an example)

I would seriously recommend anyone interested in game developing and software engineering to get this book. Unlike other books in the Xtreme game developing series. Most of them are misleading.

The professional approach
This book takes a very interesting (and possibly unique) approach to game developing. It's a detailed discussion on the development of a real game (30,000 lines of code) by a small team of game developers.

The book starts with the development of a set of requirements for the game. What's the game all about, what tools are going to be used, what is the scope of the project? Indeed, what makes a good set of requirements in the first place. From there it goes to modelling the game using UML. This step helps to visualize the system that constitutes the game. Why model, how to model? From here the next step is the basic software design. What's the structure of the program going to be? Why? ?What are alternatives? Then on to the next step and the next.

This is not a description of how the play the game, this is an introductory to intermediate (maybe even advanced) book on Software Engineering. It is oriented to gaming, but it covers the basic rules of any major software project. The approach that it uses leads you through the process one step at a time, it gives you the way professional developers approach the business. ... Read more

Product Description

THE most current Software Engineering text in the market– quality trusted coverage, practical case studies, strong lecturer support.

Customer Reviews (9)

Great service
Software Engineering: (Update) (8th Edition)

Received the book within 3 days and the book looks like new.

Wordy.
I was required to purchase this book for a Software Engineering class. This is an incredibly wordy, unnecessarily lengthy textbook. While it is apparent that the author is trying to be witty, it shouldn't take 10 pages to define a term. In the fast-paced world in which we live, this book is unsuitable.

Excellent condition
The book was delivered within the quoted time in the precise condition described.I was very pleased with my order.

Too much repetition
I used this book as the text in my software engineering class in the spring semester of 2008. When I was evaluating it for potential adoption, I did not read through it in detail, I looked over the chapter titles and subtitles, read the first few chapters and examined the exercises at the end of the first few chapters. As the semester progressed, I found myself wishing I had read further into the text.
As I moved through the chapters, I found myself mentally noting over and over again that topics are repeated. When the class was over, I asked the students their opinion of the book and they were unanimous, with no prompting from me, in saying that there is a great deal of repetition after the first chapters.
I have no complaint about the quality of exposition or the coverage of software engineering in this book. My reason for not continuing to use it in future classes is solely due to my belief that the size could have been reduced from the current 840 pages to around 600 pages with no real loss of content of flow.

too bloated
it feels like this book goes out its way to stretch easily understandable concepts into a huge 900 page book. ... Read more

Product Description
Our society has become increasingly reliant on software in the past decade; businesses have learned that measuring the effectiveness of software projects can impact the bottom line; and quality is no longer an advantage in the software marketplace (it is a necessity). For these reasons, the demand for quality in software engineering has taken center stage in the twenty-first century. In this new edition, Stephen Kan presents a thoroughly updated overview and implementation guide for software engineers faced with the challenge of ensuring quality. The book balances theory, techniques, and real-life examples to provide practical guidelines in the practice of quality. Although there are equations and formulas presented, the book's focus remains on helping the reader understand and apply the metrics and models. With this book as a map, readers can navigate through the complex field of quality, and benefit their organization by improving their processes and products. ... Read more

Customer Reviews (12)

Good about metrics, though not about their effects
Metrics and Models gives a brief summary on some major software development methodologies, as well as process standards. The bulk of the book is textbook material on how to design, execute, and interpret the results of measuring software quality. If you're asked to design a measurement or process assessment program, this text could help. But if you're more interested in how to manage teams for improvement aided by carefully-chosen metrics, instead read Measuring and Managing Performance in Organizations by Robert D. Austin.

--
Full disclosure: I only read the first two chapters and glanced through the rest.

Managing Software Development as a Science
Managing the Black Hole: The Executive's Guide to Software Project Risk

Stephen Kan's extensive experience applying "scientific methods" and measurement to the management of software development gives this book a real world practicality not found in many similar books. Anyone interested in becoming software management professional should certainly read this book and take its lessons to heart. His treatment of software defect containment practices and metrics is especially valuable.

Good overall review of metrics and methods.
A very thorough treatment of Software Engineering metrics.Good graphics.Good explanations.Much better than other books in this area.

Great book!
This book is a must have for all the managers and profesionals that need a complete and detailed reference for software metrics.It provides clear explanations and examples.It is very easy to read and very practical.

Real World Proven
As the System Test Team Leader for the Quality Technology area, I had to certify many of the tools and procedures used by Stephen Kan.Prior to that, as a System Administrator, I had to run software metrics on those tools, like those shown in table 6.3.As a design review moderator, I was charged with leading a number of IR, IE and I0 reviews.

THIS STUFF WORKS!

I can attest personally to the great effort and many find minds that worked together to develop and implement fine tools such as DCR, PTR, PTF and APAR, as well as the brilliantly simple, effective ways of implementing Continuous Quality Improvement techniques such as DPP.What Kan has written is real-world honest and true, not some academic exercise.

Kan is dead-right on the money.If you want to track, predict and manage things in the real world, this is how you do it.At PSQT '97, Tom Gilb told me that SEI should create a new CMM "Level Six" designation for the way Kan and the others at IBM Rochester have dealt with software quality.That's how good the stuff in this book is.

I am particularly impressed by how Kan has woven in not only his work and IBM Rochester as a whole, but also the work of others throughout the industry in such a simple, clear, easy to understand manner.

Yet, given that the book is an easy read, that many of the techniques are easy to do, and that I see this book on the shelves of many IT managers, it baffles me why so few people and so few companies actually implement this stuff.I suspect that politics and corporate culture is what's holding back so many companies from enjoying the success, efficiency, and frankly the FUN of working in a continually measuring, continually refining work environment such as Kan describes.

For example, Defect Removal Effectiveness is a very simple metric to gather.In a typical medium sized software company, or in the I.T. department of a large company, the head of testing and the head of phone support could easily enough get together and compare the number of bugs found in testing the last release with the number of bugs found in the field after that release was deployed.Both areas already have their problem logs, and if they can't directly pull counts and totals, it's typically only a few minutes work for the right programmer.So what's the hold up?It's not that the metric is hard to understand, or an academic exercise, or that the numbers are hard to get.It's that people have a hard time admitting that "their baby is ugly".The good of the company, stopping bugs from getting to the field, conflicts with the good of the testing manager, who doesn't want to risk admitting that problems got past them.

Therefore, I think it would be a fine addition to this book if Kan could write another chapter which deals with the human side of the equation.The book thus far presumes an interest in software metrics and appropriate management support from the top levels down.What would move this book from worker's bookshelves to their desks, and keep this book open and used on a daily basis, would be some ideas on how to garner and build support for implementing software metrics and TQM practices across an organization.People want to do this; that's why this book gets sold.Unfortunately, people aren't empowered to do so, which is why many times this excellent book sits on a shelf.

Paul Walchak
... Read more

Product Description
This guide identifies many of the key problems hampering success in this field. Covers management, all stages of the software lifecycle, quality, research, and more. Author presents ten common fallacies that help support the fifty-five facts. Softcover. ... Read more

Customer Reviews (28)

Must-read, but take it with a grain of salf
Author does a very good job at debunking common myths of software development, especially those most popular with people not involved in development process directly. However, his attitude towards opponents and lack of objectivity in the fact base render his account somewhat less persuasive than it, in my opinion, could be. I would still recommend this book to any project manager of customer willing to improve their understanding of software development. There are not too many books that do a decent job at it and are short enough.

A Great Bathroom Reader
I read this book with breakfast and supper, literally. The two to three page facts are conveniently bite-sized; this is a rare "bathroom reader" of a technical book.

I'm not trying to make light of the content: most of it is both interesting and insightful. Like his opinions or not, Glass backs up his ideas with hard data, which, as he comments himself, is sorely lacking in the field.

This book was published in 2002, but anyone caught thinking the facts are outdated is fooling themselves. Consumer-grade processors may be running three times faster (plus additional cores) than they were in 2002, but software development is far from being three times as refined.

Reading this book will make you feel more "in the know" regarding the realities of software development.

Useful summary book to core software engineering methodology
With more than 45 years experience in the software field, Robert Glass
attempts to sum up the most integral facts and dispel common misunderstandings with software engineering.

Definitely look at the table of contents for this book to determine whether you should add this book to your shelf. All of the facts and fallacies are listed in a one statement summarized format which means just looking up the relevant page information to find a more detailed statement with support or controversy.

Mr. Glass separated his book into facts and fallacies with each section
helpfully indexed within a broad category (such as Management), and then into a smaller category (such as People, or Tools). For each fact and fallacy he discussed support and controversy (if any), sources of information, and references.

In the conclusion, Mr. Glass covers 4 themes (complexity, estimation, disconnect, and hype) that are repeatedly pointed out by the 55 facts/fallacies. I found these conclusions to be the most interesting aspect of the book although they cover only half a page.

The repetition of fully covering each category before moving on to the next, limits the enjoyableness of reading the book from cover to cover, but this emphasizes that it is really a reference book for endorsing good software engineering practices. Writing that is clear and easily understood underlines Mr. Glass's great experience with this subject.

Although he repeats references within the book several times as they apply to multiple statements, this is helpful for the reader to immediately reference rather than flipping to the back of the book or chapter looking up specific numbered references. It would have been nice to include a list of all references just to know how many references there truly are, but the book in its current incarnation is a nice size to be easily thumbed over.

The intended audience is those researching and developing software, but many of the statements can be equally applied to other fields, for example system administration. Besides possibly wearing a software engineer hat, the system administrator must plan system architecture and service management with the same sort of context that the software engineer does.

For example, fact 7 is :

"Software developers talk a lot about tools. They evaluate quite a few, buy a fair number, and use practically none." (pg 25)

The gist of this fact is that as new tools for software engineering emerge, engineers rally to them, possibly purchase them, and then fall back to the well known tools they are comfortable with. The learning curve is too steep to make using the new tools productive in the short term. Similarly system administrators may find themselves talking about new tools available to better administer or monitor systems, but the learning curve to implementing these new tools is greater than writing in house solutions that are comfortable and well known. For example,a bunch of shell scripts that email information for flagged occurrences is much easier and quicker to write than understanding, instituting, and managing a more comprehensive monitoring solution with Nagios and rrdtool.

Most of the 55 statements are common sense but information that is rarely remembered at times that it should be implemented in software project design. Overall, I initially found this book to be interesting as it states some well known methodologies in one book with a number of references for additional information. For software engineers, this book is an important resource either for providing references to management in order to validate or fund decisions made on choices in software design, or for instilling good software engineering practices in the less educated engineer.

Controversial but good
As stated at the beginning of this book there are some controversial facts in there. But If you manage to put your personal bias aside you will find that it is quite useful in understanding what is going on around you and why some developers are like they are.

In short this is a book which you can debate on your blog for ages or just enjoy reading.

Pearls of wisdom, business reader friendly
This list of Facts and Fallacies usefully presents some of the more important and insightful learnings from decades of experience in Software Engineering.
This book presents items in bite-size chunks of information that concisely detail the point being made in a non-technical manner that can be understood by upper management. Each Fact/Fallacy provides references to prior established works in anaylsing the effectiveness of Software Engineering.
This is a great read. ... Read more

Product Description
This book covers the essential knowledge and skills needed by a student who is specializing in software engineering. Readers will learn principles of object orientation, software development, software modeling, software design, requirements analysis, and testing. The use of the Unified Modelling Language to develop software is taught in depth. Many concepts are illustrated using complete examples, with code written in Java. ... Read more

Customer Reviews (8)

Object-Oriented Software Engineering: Practical Software Development Using UML and Java
The book meets in a timely fashion the requirements I had for my consulting business in software development. It covers at lenght the concepts of software engineering, reusable technology and requirements development in a easy to read fashion. The added values are the introduction of design patterns and design principles in the presentation of the design concepts. Finally, the addition of testing and management concepts wraps the overall concepts of software engineering in a complete and very satisfactory fashion. This reading is highly recommended.

Outstanding
I use this book to teach an undergraduate course in software development. This book covers both agile methods (which we use) and traditional methods, as well as object-oriented design. It is very clearly written and approachable. In fact, I have the students read it on their own over the course of the semester; their reaction at the end is usually, "I wish we had read it all before the beginning of the course."

One odd thing: different branches of the publisher can't seem to agree on whether the book is in print, which causes grief to (USA) college bookstores. I ended up telling my students to order the book off the web.

An excellent textbook for undergraduate SE course
This is an excellent introductory textbook for CS courses on software engineering. It features OO, UML, iterative processes, a good treatment of software frameworks and design patterns, constructive sample projects, and complete set of slides and full-length lecture RealOne video for free downloading. It is a thin book, but it contains more updated information than many classical ones. Most importantly, the authors have the confidence to air their opinions with justification, instead of compiling and citing a lot of inconsistent historical definitions or events.

This is THE Book for Software Engineering
I used this textbook as an introduction to Software Engineering, and for the first time in my University career, I didn't find my textbook lacking or incomplete.
This book covers it all: the basics of Software Engineering, a review on Object-orientation, the software life cycle, detailed modelling in UML, architecture and design, patterns, and testing.
The material is easy-to-read, in-depth, well organized, and comprehensive. Too often, you find a book that bogs you down in its wordiness and jargon, but this isn't one of them.
This book was written by professors in the Software Engineering field who know, from years of experience, what a student needs to know in order to learn and understand the process of software engineering.
This is not a book that will sit on your shelf: I used it all the time during my first software course and still take it as my reference for all my other software courses.
I recommend it to anyone who wants to learn a lot about software.

Great text book!
This book is written in a clear language, easy to understand. I found chapter 3 (Software Development Based on Reusable Technology) very helpful with its client-server example. Excellent work! ... Read more

Product Description
KEY BENEFIT: This introduction to software engineering and practice addresses both procedural and object-oriented development. KEY TOPICS:Is thoroughly updated to reflect significant changes in software engineering, including modeling and agile methods. Emphasizes essential role of modeling design in software engineering. Applies concepts consistently to two common examples — a typical information system and a real-time system. Combines theory with real, practical applications by providing an abundance of case studies and examples from the current literature. MARKET: A useful reference for software engineers. ... Read more

Customer Reviews (5)

Not For People Who Actually Write Software
This book spends the majority of its time covering the management aspects of software engineering, with very little time covering the actual writing of the software. Many of the examples are abstract to a fault and in many cases aren't even related to writing software. This book spends only 4 pages going over Agile development methods, most of it in an extremely negative tone. The book encourages over-analyzing software engineering problems, which can create the illusion of understanding where none actually exists. Simply put, this book is amazing if you don't actually write software. However, if you enjoy agonizing over every potential problem in a software development project; if you think that comprehensive documentation is better than working software, then this book is for you.

Decent Work
This book was a required text for a graduate course in Software Engineering that I had taken. We covered about 2/3rd's of the text in class. The authors have done a pretty good job of presenting various concepts and I liked this book for the most part. In some places, the diagrams presented are very confusing (especially in design related chapters such as chapter 6 Considering Objects) since the notation used deviates from the standard UML. While I had to do a class project for the course that included design and implementation, I supplemented this book with Applying UML and Patterns by Craig Larman, which does an excellent job in presentation of UML for software design. I will recommend this book to novices to intermediate level readers in this arena. Note that this book does not cover concurrency (but only stand alone applications), so our professor used another book - Concurrency State Models and Java Programs by Jeff Magee and Jeff Kramer - for this purpose. These two books together will give an interested reader a pretty good introduction to the software engineering field.

Only syntactically correct.
Many sections of this book can be renamed to: "Random Words Put Together To Sound Like Sentences".

Not a good choice
This is a dry, historically oriented, compendium of software engineering issues. A much more readable, and very practical, introduction is McConnell's "Rapid Development" (1996) which seems much more up to date than Pfleeger's book.Read "Rapid Development" first whatever else you do. Next read one of the "Agile" intro books by Larman or Cockburn (or others). Then you'll know which of Pfleeger's topics have relevance to today's software world.

Pfleeger's only acknowledgment of the "agile" development revolution of the last eight years is four pages!

Will stay on my bookshelf after my coursework is finished.
I had to purchase this book as a required textbook for a Software Engineering course. Not only was I pleased material and the way it was presented, but I have used it numerous times as a reference book for my other software related courses. If it is on your required reading list, don't fret at the price tag like I did, pick up the book, it's a good read and worth the cash! ... Read more

Product Description

This widely used book teaches practical object-oriented software engineering with the key real world tools UML, design patterns and Java. This step-by-step approach allows the reader to address complex and changing problems with practical and state-of-the-art solutions.

This book uses examples from real systems and examines the interaction between such techniques as UML, Java-based technologies, design patterns, rationale, configuration management, and quality control. It also discusses project management related issues and their impacts.

A valuable book for development engineers, software engineers, consulting engineers, software architects, product managers, project leaders, and knowledge managers.

Customer Reviews (18)

This book is written backwards!
The only useful chapter in this entire book is the last one, where the book finally asks the question "How much process/modeling/management/etc. is enough?" for a given project.A number of methodologies are presented, that combine just a few of the techniques covered in the other 15 chapters, and discussed in the context of different types and sizes of project.

The rest of the book, comprising 15 chapters, is structured as a catalog of modeling and analysis techniques but they're presented as *the* way to develop software, according to the authors.It's only until the end that those techniques are placed in a context where they make any sort of sense.

The book also uses UML to model the activities and techniques in each chapter.This is cute, but not especially helpful and occasionally confusing.In fact, this usage serves as a helpful counter-example to the idea, espoused in the book, of UML as a catch-all modeling tool.

In lieu of this book, computer science students would be well served to study a range of methodologies and projects to which they were applied, and then to dig deeper into the techniques that make up those methodologies, according to the interest and needs of each student, in other dedicated references.

It is a very good resource not only for developers
I am a Business Analyst though not totally Agile in my approach due to the nature of my projects, being small and usually takes very short time to deliver.

I am still on Chapter 5 of the book but I find the preceding chapters very valuable to anyone involved in software engineering or systems development.

I bought the 3rd Edition of the book (which is the latest - 2010) as one of my resources in Business Analysis. Although I find this book to be a very good resource, it definitely is not for someone new to software engineering regardless of your role.

Excellent Book!
Book arrived in less than a week, and was in great condition. That's what you expect for an on-line order, and I wasn't disappointed. Thanks for a great on-line ordering experience!

Escelent condition
The book was in excellent conditions. It shipped fast and I think is pretty good book for beginners in the Software Engineering field.

Good seller! Very patient!
Good service! Although there is something wrong with the delivery, the seller is very patient!!! Book is in a pretty good condition!!! ... Read more

Product Description
This best-selling book provides a comprehensive discussion of software engineering techniques and their application in practical software projects.This book takes a broad-perspective to software engineering, offering readers solid coverage of the software process and software process technology, system integration, requirements management, and risk analysis, as well as pattern-based reuse, distributed system engineering, and legacy systems.Sommerville has incorporated coverage of new software development paradigms, namely agile methods and component-based software engineering, along with dependibilty issues--availability, security, and critical systems--making the book more in tune with current technology and practice.This book is designed for readers needing a general introduction to software engineering (development, management, and evolution), especially with regard to system requirements engineering and critical systems. ... Read more

Customer Reviews (5)

Ian Sommerville's Software Engineering
A great introductory book on software engineering. It gives you a holistic view of software engineering, but lacks in details. It won't teach you how to draw ER diagrams but it will tell you what they are.

Good introduction and explanation of software engineering
Overview of Software Engineering, with a brief explanation of software process and project management. It mainly covers the design issue and introduces the method of handling critical system.

Rather Cursory
Sommerville undoubtedly owns great knowledge over the topic. Unfortunately he has difficulties to write monolithicly. Most of the time he is beating around the bush. The examples he uses to explain the different topics are rather unusual and do not help to better understand what the techniques are all about.
More detailed and concrete examples would have been helpful.
I expected more from the Guru of Software-Engineering...

good overview of the main issues
Software engineering is to computer science what engineering is to physics, as the author suggests. Here, the emphasis is on a higher level than, say, the crafting of algorithms. The scope is for systems analysis, design and implementation. He explains that the traditional waterfall method had many shortcomings. Its monolithic stages often proved unwieldy.

The book goes into alternatives. It also gives a good overall treatment of such ideas as formal specification and architectural design. With an entire chapter focusing on the key ways to have distributed systems architectures. Unsurprisingly, CORBA gets the most extensive description. A reflection of the amount of effort that has gone into using it since the late 80s. However, there is scant mention of its drawbacks. Most important of which has been that the exchange of binary data has been very brittle.

He mentions p2p and Web Services, as contrasting approaches. Where the latter uses XML to exchange data in a readable format. This has been widely seen as a big advantage over CORBA, but the book doesn't mention it. Given the continued rise in Web Services, perhaps a future edition of the book could give it more coverage?

The most controversial part of the text might be the section on Extreme Programming. Its characteristics are well described. But perhaps not enough on its disadvantages. Like the idea of collective ownership of code. Not all programmers have the same ability or expertise. Some programmers are far better than others. It is very bad to have a tyro unwittingly change code for which she has insufficient understanding. While the author may not necessarily agree with this, he should at least describe it.

Other sections of the book, especially on testing software and validating critical system parts, are quite lucid and should excite little disagreement.

One of the best books I've read
Concise is the best word to describe it.Software Engineering covers a broad range of topics - what are software engineers, documentation, designing, architecture (types and methods) - this book is pretty much my bible on all things software engineering.

Here are some of my recommendations:

Professors: This book is best accompanied if you assign a semester long project.My prof did this and it placed the book into a different light.Half the things don't make sense if you simply read the book such as Data Flow Models or even Project Management, but when you assign a project and coincide the project with the material in the book, it's 100 times more helpful and it elucidates the material more and more.

Students: This book covers a lot, so get ready to learn new terms and methods.This book covers Project Management, which helped me out alot.For the most part, it gives you good material on how to write good documentation as well as methods and styles for how to design or architect software.Read, read, read is the best advice I can give you.

Overall, Amazon's ratings go only as far as 5 stars, I'd give this book a 10.It's a keeper in my library and a book that I'll be referencing for years to come. ... Read more

Product Description
For almost three decades, Roger Pressman's "Software Engineering: A Practitioner's Approach" has been the world's leading textbook in software engineering. The new seventh edition represents a major restructuring and update of previous editions, solidifying the book's position as the most comprehensive guide to this important subject. The seventh edition of "Software Engineering: A Practitioner's Approach" has been designed to consolidate and restructure the content introduced over the past two editions of the book. The chapter structure will return to a more linear presentation of software engineering topics with a direct emphasis on the major activities that are part of a generic software process. Content will focus on widely used software engineering methods and will de-emphasize or completely eliminate discussion of secondary methods, tools and techniques. The intent is to provide a more targeted, prescriptive, and focused approach, while attempting to maintain "SEPA"'s reputation as a comprehensive guide to software engineering. The book will be organized in five (5) parts - Process, Modeling, Quality Management, Project Management, and Advanced Topics.The chapter count will remain at 32, unchanged from the sixth edition. However, eight new chapters have been developed and another six chapters have undergone major or moderate revisions. The remaining chapters have undergone minor edits/updates. ... Read more

Customer Reviews (74)

Considered the bible of SE by many.
This book is especially useful to me because of the chapters of software testing which are usually overlooked or hardly mentioned in other books.

Overpriced but Comprehesive
I have found this book overpriced and wanting in many ways. I used it for self study and at least it is comprehensive. Other reviews point out the weakness in this approach and I agree to a point-- but, well did I mention it is comprehensive. It is far easier to research a given issue in more detail once you are aware of it, than to discover what you do not know via divine inspiration. Given that I am not taking a class, but doing self study, I personaly found it very useful in that respect.

Likewise, as an instructor, which I am not, I would find it usefulas a baseline offering to be supplemented with other materials.


The price, on the other hand is not acceptable. McGraw-Hill tiles have increased in cost almost 4 x over the last 10 years or so,and the material is not improved.

Very good and outstanding service
Very good and outstanding service, but items takes to long to arrive.
Thank you for time and business

V/R

INTULECT

The Good And The Bad
This book is great for learning about different types of tests and models in the software engineering world.I do find the book too wordy in some parts though.Some of the sentences said are not necessary because they are common sense.Overall though, if you are not looking for a book dedicated to programming and looking for a book about practices in the computer industry then I would recommend this book.

Alright I guess
First and foremost, I have not read all chapters in this book. But from what I have read, from parts 1,2,4, and 5, I agree that the text covers too much and often says that much of the methods are subjected to the particular circumstances of an individual's projects. That is, while there are many ways to do a task, you and your team or company has to settle which one you're going to use. And this is understandable, while unpleasant.
The pleasant thing would be if there were a concrete solid step-by step instruction on how to do everything. But this is impossible, because various projects may pursue various paths in developing software projects. For instance, while one project has to be done quickly and information gathering is not as wanted, other project may require more time, being laid back, and have all little requirements and details laid out at the beginning.
I understand that author wanted to cover all aspects, all approaches, and various details, and that led to a text that is not the easiest and not the most pleasant to read. But, understanding the complexity of a task at hand, and the variety of methods and opinions surrounding the software engineering, I think this text was informative.
The little quotes inserted here and then, gave this text personal touch and made it less dry. I liked those. ;) ... Read more

Product Description
Essentials of Software Engineering, Second Edition is a comprehensive, yet concise introduction to the core fundamental topics and methodologies of software development. Ideal for new students or seasoned professionals looking for a new career in the area of software engineering, this text presents the complete life cycle of a software system, from inception to release and through support. The authors have broken the text into six distinct sections covering programming concepts, system analysis and design, principles of software engineering, development and support processes, methodologies, and product management. Presenting topics emphasized by the IEEE Computer Society sponsored Software Engineering Body of Knowledge (SWEBOK) and by the Software Engineering 2004 Curriculum Guidelines for Undergraduate Degree Programs in Software Engineering, the second edition of Essentials of Software Engineering is an exceptional text for those entering the exciting world of software development. ... Read more

Customer Reviews (4)

Good book
It is hard making a subject like software engineering sound interesting... not that this book does. It is broken up well and I found that I rarely had to search for other concepts online because they were well explained. It describes many different methodologies, but I would liked for it to have explained which methodologies are used by which types of projects a bit more.

Easy to read, yet incredibly informative
I am a recent college graduate with a degree in physics. I have some programming experience, but I was looking for a way to organize the structure of my future programs. That is where Essentials of Software Engineering comes in. This book starts with the broad view of the software creation process, then dives into the details of each step.

If you are looking for a book to teach you about building software projects, this is a great choice.

Efficient
The book arrived in just a short two days, and it was in great condition.

Completely inadequate for my needs
I teach a course in software engineering nearly every year, and am always trolling for a new and better textbook. This book does not come close to satisfying my needs. While the breadth of the coverage is adequate, the depth is too shallow. If the course were structured so that the students read the book and took the test, then it would probably be minimally adequate. However, I have them develop and describe a software project using UML and only three pages of this book are devoted to UML diagrams. This is nowhere near enough for explaining what is nearly the standard means of expressing software development.
While I commend the authors for including a chapter on software maintenance, it also covers software support and is only twenty pages long. I really have no desire to teach my students how to accept and manage customer support calls. And quite frankly, they have no desire to learn how to do it. These weaknesses are unfortunate, because I found the book to be the most readable of the software engineering texts that I have examined. Very little code appears in the book, three pages are devoted to function point estimation and the phrase lines of code (LOC) doesn't even appear in the index. I also could not find the word metric anywhere in the index.
... Read more

Product Description

Software product line engineering has proven to be the methodology for developing a diversity of software products and software intensive systems at lower costs, in shorter time, and with higher quality. In this book, Pohl and his co-authors present a framework for software product line engineering which they have developed based on their academic as well as industrial experience gained in projects over the last eight years. They do not only detail the technical aspect of the development, but also an integrated view of the business, organisation and process aspects are given. In addition, they explicitly point out the key differences of software product line engineering compared to traditional single software system development, as the need for two distinct development processes for domain and application engineering respectively, or the need to define and manage variability.

Customer Reviews (2)

Good introduction to product line engineering
This book gives a good introduction to product line engineering (PLE). It highlights many of the problems and possibilities with PLE. The orthogonal variability model gives a "clean" view of variation points and variants.

The book is on a too high level for me and it does not go deeper into the subject of PLE. The orthogonal variability model works with the simple examples in the book but in real life applications it will soon be very hard to realize the model.

I can still recommend this book to anyone that wants a good introduction to PLE.

For the classroom only...
This book is an excellent classroom book, but not practical for PLE in the field.It does an excellent job of laying out a framework for a PLE process and it does an excellent job of teaching variability.The main problem with the book is that it uses the Orthogonal Variability Model to trace the variability in the project's artifacts, and there are no tools to support an Orthogonal Variability Model.It is a perfect way to teach variability, and the Orthogonal Variability Model works well in a text book context, but would not be practical on a real project.

The book makes reference to SEGOS-VM Tool, which is being developed to support the authors Orthogonal Variability Model, but it is no where to be found on the web.

So I would suggest this book only if you are interested in becoming "book smart" about PLE, it does do an excellent job of teaching the topic, but it's process holds little value for real projects.
... Read more

Product Description
For almost three decades, Roger Pressman's Software Engineering: A Practitioner's Approach has been the world's leading textbook in software engineering. The new seventh edition represents a major restructuring and update of previous editions, solidifying the book's position as the most comprehensive guide to this important subject.

The seventh edition of Software Engineering: A Practitioner's Approach has been designed to consolidate and restructure the content introduced over the past two editions of the book. The chapter structure will return to a more linear presentation of software engineering topics with a direct emphasis on the major activities that are part of a generic software process. Content will focus on widely used software engineering methods and will de-emphasize or completely eliminate discussion of secondary methods, tools and techniques. The intent is to provide a more targeted, prescriptive, and focused approach, while attempting to maintain SEPA's reputation as a comprehensive guide to software engineering.

The book will be organized in five (5) parts-Process, Modeling, Quality Management, Project Management, and Advanced Topics. The chapter count will remain at 32, unchanged from the sixth edition. However, eight new chapters have been developed and another six chapters have undergone major or moderate revisions. The remaining chapters have undergone minor edits/updates. ... Read more

Customer Reviews (6)

Fast Delivery!
The description of the item stated it was 'good' and when I received the book the only damage was a few minor scratches on the cover.And after ordering it, I received the book in less than one week!

Good Quality
It was quickly delivered, in good quality, and has lasted well since I purchased the book. The seller was true to their word!

Unbearable
This book is unreadable. I'm just three chapters in, and I can't bear the thought of having to read more. Nearly every paragraph is inflated with buzzwords, obscure new phases and acronyms. The author drones on and on about archaic software models when a simple table and summary of each would suffice. Pressman writes almost as if he is trying to fill a word quota.

Before reading this book, I believed software engineering was dead. And after reading some of this book, I now know why: Software Engineering == Software Bureaucracy.

Potential buyers of this book might want to read the article "Software Engineering: An Idea Whose Time Has Come and Gone?" by Tom DeMarco.

Waste of money
This book was purchased as a required text for a master's level class, and I am highly disappointed in it.

The book broadly and superficially covers all software engineering concepts, and to the untrained reader might appear to be a comprehensive text.Just don't look too closely.If you know absolutely nothing about the software engineering process, and want to have a high level grasp of the uniqueness that is software, then this book could be of use.The descriptions do a good job of introducing SE concepts and theories, although some are dated.

If you are tasked with developing a software engineering strategy, or running a software-intensive project, or are looking to build a solid foundation and understanding of the software engineering process, walk away.Just walk away.This book introduces new terms, redefining widely and commonly used words for the software development life cycle and others.The entire SE body of knowledge uses certain words that students and practitioners get used to, and this author seems to change them around just to be different.Furthermore, the author interchanges these terms around, and is not consistent when referring to the same concept.Not something I'd expect to see after 7 revisions.

Sucks Balls
To be fair, I haven't read most of the book, and have only been using it for about three weeks in a course I'm taking.But so far, the book seems to just be about buzzwords and trends that are sure to pass with time.It reminds me of a management class I took two years ago, but in that class, the instructor even acknowledged that most of the things covered were just buzzwords and fads.I thought this class was going to be about design patterns and various best practices, but instead I'm force fed all this management and organization mumbo-jumbo.This book is also filled with a crap-load of idealized graphs and diagrams that aren't based on any real data.That kind of stuff always annoys me.

While I think it may be worthwhile to briefly cover these methodologies to get some ideas, actually following a methodology "to-a-T" seems like a bad idea, and could possibly cripple innovation and creativity.Most of the premises behind the ideas seem to be common sense any way.Of course a business should monitor its performance, try to constantly improve it's processes, efficiently allocate resources, etc... I don't need a book full of pre-packaged methodologies to tell me that.

Also, I haven't yet entered the "real-world" yet, so I may have no idea what I'm talking about.But I would probably hate working for a company that strictly followed most of the methodologies presented in this book. ... Read more

Product Description
"It is in the "how to do it" part that this book excels, because itillustrates a process that has been successfully applied to reducecosts for organizations that develop large programming systems. Withthe help of this book, many more can learn how to exploit the idea ofprogram families and bring about a substantial improvement in thestate of practice in the software industry." --David Lorge Parnas

Many organizations have mastered the practice of softwaredevelopment, yet few have become truly efficient at softwareproduction. With the adoption of an efficient, systematic softwareproduction method, organizations can gain significant competitiveadvantages, including reduced time to market, better schedulepredictability, more reliable code, and decreased costs. SoftwareProduct-Line Engineering provides the actionable information andproven tactics necessary to effect organizational change and make yourfuture software projects more successful.

The authors outline a systematic method for rapid softwareproduction through the FAST (Family-Oriented Abstraction,Specification, and Translation) process, a revolutionary commercialproduct developed at AT&T that continues to evolve at LucentTechnologies. FAST uses practical domain engineering to decrease thetime and effort necessary to develop, deliver, and maintainsoftware. Any software development projects currently using C, C++, orJava can easily incorporate the FAST model and quickly reap thebenefits of a more efficient software methodology. ... Read more

Customer Reviews (3)

What you order is what you get
I got the book delivered within a week and the book was in the condition as mentioned.

Just another methodology book
I've just about never worked on commercial software that was shipped in only one form. There have been variations in the platform configurations, in the functional options, or in the generation of product. This book addresses the process of building families of software products, the kind that derive generally similar sets of functionality from a shared code base, i.e., the majority of commercial software in my experience.

The authors start with an obvious premise, but a premise that's overlooked far too often. They start by saying that their approach does not work in all cases, and may not work in yours - if only such honesty were more common! Although it makes the third, or fourth, or tenth member of the product family easier to develop, it incurs design and implementation costs up front. Despite long term economies, the first few family members might actually cost more than with one-off design techniques. The first step in this methodology is to decide whether the next steps will actually do you any good.

After that, though, I find this to be only an ordinary presentation of software design methodology. Although it adds steps for analyzing product families to the standard software development cycle, those steps are only a small part of the whole. At least 90% of the cycle is the same for a one-off project as for one where massive reuse is a major design goal, but the authors present the entire cycle in detail. I'd even say excruciating detail. The second half of the book, 200 pages or so, presents the methodology one step at a time, often one step per page, with forms to be filled out at each step: formal pre- and post-conditions, lists of involved participant, artifacts generated or modified at each step, and on and on and on.

Despite it's overwhelming mass of detail, I find it systematically lacking in one major respect. The first pass over the process is only a small part of any long-lived project. After that, every successive design cycle takes the entire result of the previous cycle as input. In some sense, acknowledgement of the past is the first and biggest requirement, where the past consists of all code and documentation artifacts from the previous effort. "Green field" construction is a rarity in the software world, but a premise of most design methodologies, this one included. The second major weakness in this book may just be a matter of editorial choice: it addresses the organizational aspects of the project only, with few (if any) tips for the technologist creating a line of products. The techniques of design for flexibility, especially for variation over time, cover whole ranges of topics that aren't part of this dicsussion.

So we're left with a mass of imposing organizational detail, with reams of families of forms and formalities. These could become oppressive if not handled in a context-sensitive way, but the authors say little about tailoring the process to different environments. And, anong what's presented, only a small part is specific to the product-line problem as opposed to any other software development. I'm still looking for stronger technical advice and a more flexible approach.

//wiredweird

A fair introduction, a good reference...
This book really deserves two separate ratings.The first five chapters introduce domain engineering in general.If you are new to the idea of family-based software development, or need some convincing of its intendedbenefits, this section isn't bad.The two case studies presented glossover some of the complicated concepts while providing too much technicaldetail in others.For example, the important but non-trivial job ofcreating the "decision model" for the domain is given minimalcoverage.On the other hand, every class in the JAVA code used toillustrate one example is explained individually.I'd give this section a3-star rating as an introduction to domain engineering.

The rest of thebook is an incredibly detailed reference into the authors' implementationof the FAST process.They spend two chapters bringing the readerup-to-speed on the process modeling technique called PASTA.Then theyprovide almost 200 pages of reference information (also included on CD-ROM)on the specifics of FAST.If you are looking for a recipe to use to trydomain analysis and implementation in your company, this section covers it. If nothing else, you'll see a very well defined process modeling notationin action, one that can be used in many applications.Without any personalexperience implementing the process, I hesitate to rate this section.Butif the process works as well as this section is detailed, I'd give it atleast 4 stars.

Its hard to say from their examples how well the FASTprocess will scale to industrial-size domains.But the authors havepresented an easily read book with enough detail that a motivated softwareengineer may be able to win management support and give domain engineeringa try. ... Read more

Product Description
Designed to assist students and professors in software engineering courses and degree programs, Schaum's Outlinne of Software Engineering presents the theory and techniques of software engineering as a series of steps that students can apply to complete any software project successfully. An ideal supplement to all leading textbooks, it provides more than 200 detailed problems with step-by-step solutions, clear, concise explanations of all relevant concepts and applications, and complete coverage of the material taught in the course. ... Read more

Customer Reviews (5)

Superb outline hits the main points of software engineering
This Schaum's outline does a great job of outlining the vast majority of topics you must study in order to call yourself a software engineer versus a programmer. As other reviewers have pointed out, it is not a comprehensive textbook on the subject but makes a great "big picture" supplement. This is particularly valuable to students since college software engineering classes are often poorly structured and taught. When I took software engineering at Virginia Tech the professor actually believed that learning software engineering involved memorizing every UNIX command and all of its options. Thus guidance in this discipline is at a premium.

This book's format is to mention all of the major subtopics of software engineering, provide a paragraph or two in description, and then provide some examples as well as exercises for the student. No particular programming language is used since this is not a book about programming, rather it is about the tools and metrics used to organize, manage, measure, and test programming projects. Everything from project management to metrics to object-oriented design techniques is at least mentioned.

Although there is no formal bibliography given, throughout the book there are references to the work of authors and experts in the field who have written more extensive works on particular aspects of software engineering such as Glenford Myers who authored the classic "The Art of Software Testing", Watts Humphrey author of "Introduction to the Personal Software Process", and Tom DeMarco who penned "Controlling Software Projects". I highly recommend this outline to students of software engineering and also to professionals who might need a quick reference for certain aspects of the field that they may have forgotten.

Telegráfico pero útil como introducción.
Acostumbrado a otros libros de textos, llenos de ejemplos de cómo no funcionan las cosas, o al contrario de ejemplos que confirman las bondades de las teorías expuestas, éste se reduce a la esencia mínima.

Se describe el concepto y se ponen ejemplos (sencillos en la mayor parte de los casos), nada más y nada menos. Cierto que muchas veces el tópico es ciertamente complicado de entender o la literatura es muy amplia, pero si en lo único que estás interesado es en conocer la idea básica tras el concepto, este libro es el adecuado. Mayoritariamente, con aplicar básicamente lo que aquí se describe uno tiene más que sifuciente para abordar la mayoría de los proyectos de seguimiento de software. Todavía no he visto ninguna organización (y ya he estado en varias y con proyectos de gran envergadura) que incluya métricas de seguimiento, como las básicas que aquí se describen (control estadístico) o incluso un simple análisis PostMortem del proyecto.

Quedan para otros libros más detallados, pero también menos asequibles, el entender el "por qué" de lo que en este se cuenta.

Carlos Ortega
2006-01-30

Remember:it's an OUTLINE!!!
I purchased this as a required book for a graduate course I took (CS 5704 at Virginia Tech).It is an excellent roadmap for a broad scope of software engineering topics.But you should expect to treat it as a directory of topics from which you must branch out for more in-depth treatment and experience of the topics.

The book is generally well written.Is is very readable and clear, though I do have some complaints.Many topics presuppose other knowledge referenced nowhere else in the book.For example, Chapter 5 on Software Metrics includes a short section on Statistics, which refer to Spearman correlations and Pearson correlations, with no clue as to what they are.

One area in particular, Software Project Management, is 16 pages in its entirety.I have been a software development manager since 1988 and it is almost criminal to lead anyone to believe that what they need to know about this topic in 16 pages.The material there is quite good, and I learned something new myself, but the brevity could be quite misleading to a naive student.

Many chapters in this book are deserving of having one (or more) college courses dedicated to the subject.Software Design alone, a single chapter here, takes years to master the concepts described.

However, this book is marketed as an outline, and a very good outline it is.

Basic Outline
This is a good basic outline of Software Engineering. It accurately covers many areas, but not in depth. This is what I expected from this outline and it delivered. It will get you started in the right direction.

Concise, yet thorough descriptions of software engineering
Learning a subject from a Schaum's outline is generally a difficult endeavor. With the emphasis on solved problems and very little explanatory text, there is not a great deal of depth to the coverage. I have used many of them over the years as a source of problems. Sometimes these problems were a supplement to self-study using other more detailed works and other times I have used them as inspiration for classroom examples and test questions.
I used this outline as a source of ideas for topics to cover in my software engineering class in the Spring semester of 2004. What I found most helpful about the problems is that they are concise. By examining a solved problem, I can see at a glance what the problem needs to cover and possible ways to organize the presentation. I did not take problems directly from the book, if the topic is to be covered as an example in class, then it is necessary to include more explanation. For example, I spent some time on Metrics for Object-Oriented Design (MOOD) in the class and the section in this book was very helpful. However, understanding the elements ofMOOD requires detailed knowledge of object-oriented concepts such as encapsulation, inheritance and polymorphism.
While necessarily brief, the coverage in the book is thorough. Nearly all of the areas considered core to the study of software engineering are mentioned. With plenty of charts and graphs to illustrate them, this book is a solid, albeit limited educational tool. ... Read more

Product Description

Enterprise-Scale Agile Software Development is the collective sum of knowledge accumulated during the full-scale transition of a 1400-person organization to agile development—considered the largest implementation of agile development and Scrum ever attempted anywhere in the world.

Now James Schiel, a certified Scrum trainer and member of the Scrum Alliance, draws from his experience at the helm of that global four-year project to guide you and your organization through the transition. He lends his insight on how you can use Scrum as an organizational framework and implement XP practices to define how software is written and tested. He provides key information and tools to assess potential outcomes and then make the best corresponding choices in any given situation.

Schiel sequences chapters to match typical developmental progression, and in addition to practical guidance, he provides a tool kit from which you can take ideas and select what works for you. Covering quality development practices based on ISO 9001, which help you create consistently high-quality software in a cost-efficient manner, this invaluable resource shows you how to—

• Improve project management practices and product quality assurance
• Adopt new management methods and requirements
• Involve your current customers in development, while inviting new ones

Much more than a mere "body of knowledge," this volume goes beyond standardizing agile and Scrum practices. It breaks up the process into manageable tasks, illustrating how to set the stage for the change, plan it, and then initiate it. Using the methods and information presented, any organization should be able to achieve a nearly seamless transition to agile.

Customer Reviews (1)

A good path through the thorny thickets of agile transformation
Many books have been written about agile development processes, such as Scrum and XP. Fewer books address the hard problems of scaling agile practices to large projects, or of how to introduce agile processes to the enterprise.

Jim Schiel has bitten the bullet, and written a realistic and detailed guide for conducting agile transformations on a large scale. Drawing on many years of experience, Schiel provides step-by-step guidance for how to lead an enterprise through the transformation to agile development. The encyclopedic scope of this well-written volume covers topics ranging from stakeholder involvement and policy definition to best practices for continuous integration and test automation.

Those who are unfamiliar with Scrum and XP will learn a lot about these frameworks. Those who are familiar with them will learn how to bring them into an enterprise, successfully.

Highly recommended.
... Read more

Product Description
Practical Software Engineering presents an introduction to software engineering for a first course. Using the C language, the text stresses the themes of software development by teams; the importance of maintenance; reusability; complete and correct documentation; testing throughout the life cycle; and the use of (CASE) computer-aided software engineering tools to boost productivity. The use of dialogues and a continuous case study enhances understanding of the concepts presented. The text is intended for sophomore to senior level students being introduced to software engineering in computer science, management information systems (MIS), data processing, or wherever students are new to the subject. ... 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
After completing this self-contained course on server-based Internet applications software, students who start with only the knowledge of how to write and debug a computer program will have learned how to build web-based applications on the scale of Amazon.com. Unlike the desktop applications that most students have already learned to build, server-based applications have multiple simultaneous users. This fact, coupled with the unreliability of networks, gives rise to the problems of concurrency and transactions, which students learn to manage by using the relational database system.

After working their way to the end of the book, students will have the skills to take vague and ambitious specifications and turn them into a system design that can be built and launched in a few months. They will be able to test prototypes with end-users and refine the application design. They will understand how to meet the challenge of extreme business requirements with automatic code generation and the use of open-source toolkits where appropriate. Students will understand HTTP, HTML, SQL, mobile browsers, VoiceXML, data modeling, page flow and interaction design, server-side scripting, and usability analysis.

The book, which originated as the text for an MIT course, is suitable for classroom use and will be a useful reference for software professionals developing multi-user Internet applications. It will also help managers evaluate such commercial software as Microsoft Sharepoint of Microsoft Content Management Server. ... Read more

Customer Reviews (6)

Not informative
This book does not provide any new material about the title topic. I returned it

Practical advice for web applications design in the real world
This is a terrific book on what it takes to make web applications really work (both for users and for the businesses that create them). Managers of web design projects should read this book for its eminently practical advice on documentation, workflow, and pitfalls to avoid. Highly recommended.

Excellent book teaching nontrivial material.
It's not easy to build a really good online community website.There are a lot of things to think about, and many of them have little or nothing to do with technical programming skills.

Buy this book, read it, step through it, and learn from some of the best teachers on the subject.And then when you've learned what they have to say here, take your new-found skills and build your own online community site.Using the methods in this book, your web sites can be more useful, successful, and profitable.

Specific examples, great ideas
This book is helpful for programmers as well as people who work more generally with technology. I'm using very specific, technical information from the "Adding Mobile Users to Your Community" chapter for a web application I'm building, while using concepts from the chapter on discussion forums for a research project on how discussion tools are used at my university.If you build web applications, or work with people who do, I highly recommend this book.

Useful textbook for web application makers.
If you're new to building web applications and want a balanced perspective on the engineering challenges involved -- from understanding user needs to data modelling to scaling gracefully --this book is a great place to start.It's mostly language-agnostic, so it'll be a good starting point for a few years but won't update you on the latest technology.Nevertheless, I know very few web developers who wouldn't learn something important from a careful reading of this book.

Where this book really shines is as a bridge from the world of college Computer Science to the world of actually building applications people use.This transition encompasses understanding your users, making flexibile designs, considering security, aesthetics, and a host of other issues one does not actually learn in a normal college CS curriculum.Thanks to its project focus, this book (and the course curriculum it implies) seeds an awareness of these many issues that can later be developed through experience.Other "software engineering" books over-emphasize theories, but this one will actually press you to get stuff built. ... Read more

Product Description
Software and Hardware Engineering: Motorola M68HC12 is the second in a series of processor-specific texts designed to stand alone or to accompany Cady's previous book, Microcontrollers and Microcomputers: Principles of Software and Hardware Engineering (OUP 98). This two-text concept provides well-written text coverage of the general principles of software and hardware design. This accompanying processor-specific volume allows professors to choose a particular microcontroller for their course/lab work. The previous text focused specifically on the Motorola M688HC11. This text provides an introduction to the architecture and design of software and hardware for the Mortorola M68HC12. Specifically, it covers the hardware features of two versions of the M68HC12 -- the M68HC12A4 and the M68HC912B32. In addition to covering and comparing features common with its M68HC11 predecessor, this text features chapter on fuzzy logic and how to program a fuzzy inference engine. A detailed appendix explains the design of software for a debugging pod. There are more than 100 extensive programming examples. This text will provide the beginning student with specific material and examples to apply the Motorola M68HC12 microcontroller in real-world applications. It is written so that a student or engineer familiar with the Motorla M68HC11 will be easily assimilate the differences between it and the M68HC12. It is suitable for undergraduate students in electrical engineering or technology programs in electrical and computer technology.

This text can be used with its companion volume, Microcontrollers and Microcomputers: Principles of Software and Hardware Engineering, or with any other book that examines the general principles of microcomputer technology. It can stand by itself in a course devoted to the M68HC12. ... Read more

Customer Reviews (5)

Not much more than the Documentaion Rehashed.
You can get this book used for 3.00, because that is about what it is worth.

While the authors seem to understand hardware, I seriously question that there is much in software of value here.

You will pay a lot more for:
"The HCS12/9S12: An Introduction to Hardware and Software Interfacing"
But it is worth every penny.

Foundation for Programmble Hardware
This book is used for the classic junior level microprocessor class at Montana State University - Bozeman (where Cady teaches) and is the starting point for modern digital design. After an "Intro to Logic Circuits" class this book then gives the essential foundation to build upon with more advanced design classes. The microcontroller book (also by Cady) comes after this one.

Highly Recommended - Very Valuable
This book, and potential customers, have been done a great disservice if they've been misled by previous customer reviews. While not for beginners, that fact does not take away from the value of this book to others. And it is far more than just data sheets. Anyone who's tried to learn a new microprocessor strictly from data sheets will certainly recognize the value of this book. It does not replace the data sheets; it supplements them. It straddles well the region between primers and reference material.

The intended audience for this book is college Engineering students, or people already familiar with microprocessors. A highly motivated beginner could use this book as well, but they would probably need access to someone with experience to answer questions when they get stuck. (For a more beginner's book see Fredrick Cady's "Microcontrollers and Microcomputers - Principles of Software and Hardware Engineering".) Familiarity with the HC11 could be helpful, but it's not required. I have never worked with the HC11, and I found that of little consequence.

The HC12 is an amazing microcontroller. But gleaning and understanding the necessary material from the 400 pages of Motorola data sheets isn't easy. The authors, one of whom helped design the HC12, have already done that for you. Several very useful, but complex peripherals have been integrated into this line of microcontrollers, in addition to tons of parallel I/O. But what initially attracted me to this chip were the native Fuzzy Logic instructions. The authors do an excellent job of detailing an "example" Fuzzy Logic application, and the basics of Fuzzy Logic. It's worth the read for no other reason than that.

Modern microprocessors and microcontrollers have become very complex. Learning a new one without the help of a colleague, strictly from the data sheets is a monumental task. This book can fill that gap well. My one criticism is its age. Published only in 2000, it is already out of date regarding some of the newer versions of the HC12. The A4 and B32 are covered in this book, and while the B32 is still a workhorse suitable for many applications, some of the newer chips include many additional features and peripherals. A new edition that dealt with those would be useful.

If you're interested in learning the HC12 and/or Fuzzy Logic, I highly recommend this book.

This book is terrible
This book is in no way for beginners. This book talks about Assembly language for the HC 12 without detailed explanation of the code. If you do not understand assembly language you are lost with this book. However the book is a good reference once you understand the basics. A good book for beginners with some level of C programing knowledge is Embedded Microcontrollers by Tood Morton. it explains the assembly code in comparison to C/C++ code.

A copy
It's a kind of a copy of M68HC12 data sheets. ... Read more