Product Description
No book on software project management has been so influential and so timeless as The Mythical Man-Month. Now 20 years after the publication of his book, Frederick P. Brooks, Jr. (best known as the "father of the IBM System 360") revisits his original ideas and develops new thoughts and advice both for readers familiar with his work and for readers discovering it for the first time.Amazon.com Review
The classic book on the human elements of softwareengineering. Software tools and development environments may havechanged in the 21 years since the first edition of this book, but thepeculiarly nonlinear economies of scale in collaborative work and thenature of individuals and groups has not changed an epsilon.If youwrite code or depend upon those who do, get this book as soon aspossible -- from Amazon.com Books, your library, or anyone else. You(and/or your colleagues) will be forever grateful. Very HighestRecommendation. ... Read more

Customer Reviews (151)

A must read for anyone working on a software development project.
This is a classic collection of essays by Frederick Brooks based mostly on the IBM OS/360 project back in 1975.
The interesting and surprising fact is that although the technology has improved tremendously for the last two decades, most elements & challenges we face in Software development projects today are nothing different to what it was 20yrs before. Example: throwing more people to a late/troubled project making it delay further. This is the core concept he highlights throughout the book; men and months are not interchangeable.

Certain chapters are somewhat outdated especially in the scenarios where he talkes about software development in '70s with low level programming languages, assemblers, punch cards etc. However, the views, the concepts and the lessons are still valid for today's projects. The extra burden on reading definitely offset the value you get and the lessons learn after reading this book. Thus makes it a good investment

A good, undying, informative, inspiring and enjoyable read!
I learned by my own mistakes the meaning of the expression, "You can pay me now or pay me later." There are few or sometimes no short-cuts in software or hardware development or engineering, or electronics in general. Fred Brooks, best known as the "father of the IBM System 360," and after 30 years still holds the title of the most influential book on software project management, likened it to pregnancy. He said you can add all the women you want "to the project" and still, it will take nine months! That's why, in managing software development projects, I learned to spend ample time with the software developers beforehand. Otherwise, I would inevitably spend the time with them afterwards. I was the one knowing the design. I had the "big picture" that needed to be communicated to them.

In his book, Brooks described the foibles of the early design teams and programming at IBM. From his own mistakes, he came up with snappy principles like "If you don't have time to do it right the first time, when will you find time to do it over?" He also coined what became known as the "Second-System Approach," which basically said "by the time you finish developing a system, you know what you should have done"--therefore, throw it away and start from scratch again. He identified the corruptible optimism of good intentions that truly but erroneously believed, for most of the project, that the work was 90% done or that debugging was 99% done most of the time. He insisted, "Ask whenever there's a doubt. NEVER assume anything."

This book is filled with timeless development advice by a master from a previous age. The advice, however, is as valuable now as it was then.

A good, undying, informative, inspiring and enjoyable read!

While I may take heat for this but...
I have to admit, I did feel as I was reading that the text was a bit outdated and while I agree to many of the topics in the book there were also a lot of times I found myself thinking about some of the problems he had presented in the book as not being as applicable anymore.Perhaps its the semi-dated stories, the book (or at the least the second edition I had read) is already 15 years old.While I do feel I got some good information out of it, it would not be in the "if I you only could read one programming book this year" conversation.

Not that useful - pretty out-dated
This book is supposed to be a classic about software project management, maybe because it was the first to actually cover the topic and offer advice and solutions back in the 70s. Even though most principles still apply, the arguments have aged rather badly and do not translate very well in nowadays environment. I have the feeling I haven't learnt anything that I didn't already know, which is somehow frustrating.

Mythical Man-Month - a period piece
Fred Brooks discusses his experiences as a project leader in the 1960s.In the process he promulgates many lessons which he has learned.Some of these are merely opinions, but others are world-class propositions which IT professionals should pay attention to. ... Read more

Customer Reviews (1)

Still relevant
I just read chapter 1 and I'm excitedly awaiting the remaining book. It seemed like this could have been written this year. All of the issues cited in Chapter 1 are relevant and faced today in the industry. Some of the words are different but all of the facts seem the same.

... Read more

Product Description
Praise from the Reviewers:

"The practicality of the subject in a real-world situation distinguishes this book from others available on the market."
—Professor Behrouz Far, University of Calgary

"This book could replace the computer organization texts now in use that every CS and CpE student must take. . . . It is much needed, well written, and thoughtful."
—Professor Larry Bernstein, Stevens Institute of Technology

A distinctive, educational text onsoftware performance and scalability

This is the first book to take a quantitative approach to the subject of software performance and scalability. It brings together three unique perspectives to demonstrate how your products can be optimized and tuned for the best possible performance and scalability:

• The Basics—introduces the computer hardware and software architectures that predetermine the performance and scalability of a software product as well as the principles of measuring the performance and scalability of a software product
• Queuing Theory—helps you learn the performance laws and queuing models for interpreting the underlying physics behind software performance and scalability, supplemented with ready-to-apply techniques for improving the performance and scalability of a software system
• API Profiling—shows you how to design more efficient algorithms and achieve optimized performance and scalability, aided by adopting an API profiling framework (perfBasic) built on the concept of a performance map for drilling down performance root causes at the API level

Software Performance and Scalability gives you a specialized skill set that will enable you to design and build performance into your products with immediate, measurable improvements. Complemented with real-world case studies, it is an indispensable resource for software developers, quality and performance assurance engineers, architects, and managers. It is anideal text for university courses related to computer and software performance evaluation and can also be used to supplement a course in computer organization or in queuing theory for upper-division and graduate computer science students.

  ... Read more

Customer Reviews (8)

Perfect Quantitative (Quality) approach Performance and Scalability
This is one book which can cater for any section of software development work force (school/high school or undergraduate or graduate or instructor or software rofessional). The book is aptly organized and have a upbeat flow of information from beginning to ending. I would say any performance test engineer should read this book before submitting a performance test plan for any application. I would say any software developershould read this book before designing any feature. With my 14 years of experience API profiling is most over looked or given least attention in the initial design and people do patch up at end of the release. The chapter on API profiling framework should be eye opener for many brains. Amdahl's law and the case study speaks volume about the author and his experience. Effective optimization and tuning techniques can be a very handy especially for applications which are years old and still exist. Overall it was a complete quantitative, qualitative, practical approach to performance and scalability. I highly recommend this book to anyone who is serious about performance and scalability. - Bala (Bangalore, India).

Very valuable for those who worry about performance and scalability
Performance and scalability are not the easiest engineering aspects. It requires careful thought, sincerity and knowledge of some basic representation techniques. Dr Liu does a great job in presenting these aspects. How to vary parameters, how to rely more on facts rather than emails/thoughts/perceptions, how to measure performance step by step, the importance of small but smart utilities are some of skills that are really worth picking up as soon as possible.

If you are serious about creating an enterprise class product which requires high performance, high scalability - and still should be reliable, this book would be a good addition to your library.

An excellent educational textbook on software performance
As a person who has no exposure to enterprise performance before, I greatly benefited from reading this book. It is an excellent educational textbook for me to grasp the basic concepts of software performance and scalability and master the quantitative approach to tackle any enterprise performance issues. I really like those usecase studies following each chapter, which help readers a lot to apply the abstract theory learned from each chapter to real-life scenarios. As a person who favors mathematical approaches, it is a really enlightening reading for me to see how Dr. Liu applies the queuing theory and classical probability models to solve enterprise performance and scalability measurement problems. Strong recommended for anyone who are interested in performance subject. In his future editions, I hope that Dr. Liu can cover more performance issues on virtualization environments.

Excellent coverage of the subject
I have greatly benefited by reading this book. Provides an excellent coverage of the subject.The book provides both the analytical and measurement aspects of performance and scalability.There aren't many references that cover these subjects.I felt the author could have covered some areas like - Virtualization and its effects on performance and scalability and some real world web services deployment scenarios.

Strongly Recommend!
I strongly recommend Dr Liu's "Software Performance and Scalability: A Quantitative Approach" for anyone involved in designing, constructing, testing, or managing delivery of enterprise applications.Having started as a software engineer and now leading development organizations for the past fifteen years I can attest and relate to the challenges that Dr Liu introduces in his text.Too often performance is an afterthought and implemented with adhoc processes and untrained resources.

Dr Liu delivers a well structured book that provides the quantitative foundation necessary to actually build performance into a solution and test and just as importantly, effectively tune or troubleshoot through instrumentation.The book provides a very effective blend of hard quantitative studies with practical examples yielding a book that is extremely thorough, easy to read, and informative.

A must read for any software designer, developer, tester, or leader accountable for delivering performant solutions.A definite must have for anyone in, or studying to be in, the performance engineering field. ... Read more

Product Description

“This book’s broad overview can help an organization choose a set of processes, policies, and techniques that are appropriate for its security maturity, risk tolerance, and development style. This book will help you understand how to incorporate practical security techniques into all phases of the development lifecycle.”

Customer Reviews (1)

A disjointed rehash of earlier material
The Addison-Wesley Software Security Series is generally a great collection, with titles like Software Security: Building Security In (my rating: 5 stars), Rootkits: Subverting the Windows Kernel (my rating: 4 stars), and Exploiting Software: How to Break Code (my rating: 4 stars).I particularly liked the first of those three (SS:BSI), which I reviewed last year.I felt Gary McGraw wrote "a powerful book with deep truths for secure development."Software Security Engineering (SSE), by a collection of authors, pales in comparison to SS:BSI.You can skip SSE and stick with SS:BSI.

I started reading SSE very closely, underlining key concepts and looking for important ideas.About halfway through the book I realized it was mainly a collection of ideas from other sources.Very rarely do I read books that successfully present a dozen approaches to the same problem.What usually happens (as is the case with SSE) is the reader is left reading overlapping material and fragmented points of view.Frequently I found myself wondering "so what am I supposed to do with this?Where do I start?What approach matters?"

It is especially problematic when a book contains articles essentially republished from magazines.Each article author needs to frame the problem to make sense for the short period during which he has the attention of the reader.That works for a stand-alone article, but it doesn't work when all of these previously stand-alone articles are collected in one book.I can accept a book published as a series of independent works, with an editor overseeing the affair.I can't accept a book published as a single work, with magazine articles inserted at various intervals.It's incoherent and confusing.

Still, I found a few ideas interesting.Page 79 (a reprint of a 2004 IEEE article) says "Security is an emergent property of a system, not a feature. This is similar to how 'being dry' is an emergent property of being inside a tent in the rain. The tent keeps people dry only if the poles are stabilized, vertical, able to support the weight of wet fabric, and so on. Likewise, the tent must have waterproof fabric that has no holes and is large enough to protect all the people who want to stay dry. Lastly, all the people who want to be dry must remain under the tent the entire time it is raining. Whereas it is important to have poles and fabric, it is not enough to say, 'The tent has poles and fabric, thus it keeps you dry!'"

Page 73 (a reprint of a 2006 Build Security In article) says "When security requirements are considered at all during the system life cycle, they tend to be general lists of security features such as password protection, firewalls, virus detection tools, and the like. These are, in fact, not security requirements at all but rather implementation mechanisms that are intended to satisfy unstated requirements, such as authenticated access."

Page 59 (another reprint of a 2006 BSI article) says "Software can be designed and developed to be extremely secure, but if it is deployed and operated in an insecure fashion many vulnerabilities can be introduced. For example, a piece of software could provide strong encryption and proper authentication before allowing access to encrypted data, but if an attacker can obtain valid authentication credentials he/she can subvert the software's security. Nothing is 100 percent secure, and the environment must be secured and monitored to thwart attacks."

Pages 39-40 say "In software systems that include acquired or reused (commercial, government off-the-shelf, open-source, shareware, freeware, or legacy) binary components, application defense techniques and tools may be the only cost-effective countermeasures to mitigate vulnerabilities in those components."

Page 35 says "Maliciousness... makes the requirements of software security somewhat different from the requirements of safety and reliability.Failures in a reliability or safety context are expected to be random and unpredictable.Failures in a security context, by contrast, result from human effort (direct, or through malicious code)."

If you want to read a good overall book on software security, read McGraw's SS:BSI. ... Read more

Product Description
An effective, quantitative approach for estimating and managing software projects


How many people do I need? When will the quality be good enough for commercial sale? Can this really be done in two weeks? Rather than relying on instinct, the authors of Software Measurement and Estimation offer a new, tested approach that includes the quantitative tools, data, and knowledge needed to make sound estimations.

The text begins with the foundations of measurement, identifies the appropriate metrics, and then focuses on techniques and tools for estimating the effort needed to reach a given level of quality and performance for a software project. All the factors that impact estimations are thoroughly examined, giving you the tools needed to regularly adjust and improve your estimations to complete a project on time, within budget, and at an expected level of quality.

This text includes several features that have proven to be successful in making the material accessible and easy to master:
* Simple, straightforward style and logical presentation and organization enables you to build a solid foundation of theory and techniques to tackle complex estimations
* Examples, provided throughout the text, illustrate how to use theory to solve real-world problems
* Projects, included in each chapter, enable you to apply your newfound knowledge and skills
* Techniques for effective communication of quantitative data help you convey your findings and recommendations to peers and management

Software Measurement and Estimation: A Practical Approach allows practicing software engineers and managers to better estimate, manage, and effectively communicate the plans and progress of their software projects. With its classroom-tested features, this is an excellent textbook for advanced undergraduate-level and graduate students in computer science and software engineering.

An Instructor Support FTP site is available from the Wiley editorial department. ... Read more

Customer Reviews (5)

Kindle price for the book
There are better chances for this book to sell, if Amazon dropped the kindle price to 9.99. Why would I pay 65 USD for an electronic copy?

Very Good Book
It is amazing how much information could be packed into a book of only 250 pages (approximately). This is probably the best book one can currently buy for a good introduction to software measurement and estimation. It is both a guide for students as well as a reference for software measurement practitioners. The book contains small imperfections that can be fixed and by no means reduce its value. They will certainly be corrected in a future edition. Comments below:

- Chapter 1 / Section 1.4 about the CMMI mentions the Project Planning and Project Monitoring and Control process areas (PAs) but fails to mention the Measurement and Analysis process area - that has everything to do with the book's theme.

- Chapter 2 provides a short (and good) description of the GQM (Goal/Question/Metric) approach but fails to mention the PSM (Practical Software & Systems Measurement) methodology, even though the PSM book is listed asreference [3] at the end of the chapter. Also, Section 2.3 is titled "Method 3: Standards Driven Metrics" but does not mention the ISO/IEC 15939 standard (Software Engineering - Software Measurement Process), which is related to the CMMI Measurement and Analysis PA and also to the Practical Software & Systems Measurement initiative. Any book on Software Measurement should cover the ISO/IEC 15939 standard.

- Chapter 3 contains a very good explanation of measurement scales, measures of central tendency, measures of variability, measurement errors, accuracy, and precision.

- Chapter 4 is about software sizing. Even though the coverage is very good, the chapter fails to inform the reader that 3 of the FSM methods - IFPUG, NESMA (Netherlands Software Metrics Users Association, not even mentioned), and COSMIC have become ISO standards. It should also be said that IFPUG considers the Value Adjustment Factor optional since 2003. The main IFPUG Function Point reference, the Counting Practices Manual, is not listed as a reference at the end of the chapter.

- Chapter 5 features a good introduction to complexity measures, including McCabe's cyclomatic complexity,Halstead's measure, and the Agresti-Card-Glass system complexity metric. Object-oriented design metrics are also covered in this chapter. The author explains those measures very clearly including examples.

- Chapter 6 is about effort estimation. Again the author provides excellent and comprehensive explanations of several estimation models, such as expert opinion (including Delphi), benchmark data, analogy, proxy points, custom models, and algorithmic models. On page 96 the author directs the reader to reference [10] for the IFPUG website. As it turns out, reference [10] on page 116 points to the website of a consulting company. It would be nice to have this fixed in the next edition of the book. On page 104 COCOMO II is mentioned but the example on page 105 uses COCOMO 81. The reader should be aware that COCOMO 81 has been replaced by COCOMO II. On page 106 some estimation tools are listed, namely COCOMO, SPR, and Checkpoint. COCOMO itself is not a tool so it would have been better to use the USC COCOMO II free tool as an example, as well as commercial tools such as COSTAR and Cost Xpert. SPR is listed as a tool when it is actually a company that used to sell the Checkpoint tool that has been replaced by KnowledgePlan.

- Chapter 7 provides the reader with a very good introductory treatment of defects. Figure 7.6 on page 122 depicts a size-defect relationship that has been "linearized" through the use of a log-log scale. That should be clearly explained (the text refers to the relationship as linear). Overall this is an excellent chapter.

- Chapter 8, 9, and 10 are, respectively, about reliability, response time and availability, and measuring progress. They are all very good and I can only recommend them. Excellent explanations and references.

- Chapters 11 and 12 - Outsourcing and Financial Measures - seem a little displaced in this book, even though they can still be useful for students.

- Chapter 13 on Benchmarkingis perhaps too short to give the theme a fair treatment.

- Chapter 14 on Presenting Metrics to Management is very interesting and potentially useful to measurement analysts. The author teaches the reader how to create a dashboard for all metrics to be viewed as a whole.

What I like about this book is that it deals with the most important topics of software measurement and estimation without being bulky or tedious. The language is simple and keeps the reader interested throughout the 250 pages. Recommended.

I hope this review helps potential readers as well as the author of this very good book.

Excellent Book
This is the probably the first book to contain most of the information I needed know about Software Measurement and Estimation in simple and easy to understand language. It contains excersises to practice what you have learned. Overall an Excellent book. Well written Linda. Thanks

Excellent book.
I bought this book after going through the Table of Contents. After reading some chapters, I am convinced that it is a good buy. The book is written in a simple language and is well structured with good examples thrown in. I found the chapters 'Measuring Size' and 'Estimating Effort' especially well presented. The References listed at the end of the chapters is extremely useful and allows one to explore certain topics in greater detail.

One drawback is that the problems listed at the end of the chapters do not have solution key and the FTP site is not available despite the claim on the front cover. The good news is that one of the authors (Linda) emailed me to state that creating the FTP site was her next project !!!

Overall, an excellent book on a yet to be fully understood software engineering topic.

Outstanding book!
I've been working on a web application project. I needed to analyze and estimate the reliability of my project. Using the techniques presented in this book (especially chapter 7 - Defects and Defect Metrics), I was able to predict the reliability of my project. Starting at the beginning of the project, I used my history data from other projects for calculations. As I progressed to the test phase (I used incremental model), I was able to estimate the reliability based on the defects collected during the testing phase. I highly recommend this book especially if you are software engineering major. ... Read more

Product Description

This book covers two applications of ontologies in software engineering and software technology: sharing knowledge of the problem domain and using a common terminology among all stakeholders; and filtering the knowledge when defining models and metamodels. By presenting the advanced use of ontologies in software research and software projects, this book is of benefit to software engineering researchers in both academia and industry.

Customer Reviews (2)

Perspicacious
There are few books available in the area of Ontology for software engineering and this is one the best. The book has eleven chapters, structured in three sections: Introduction, Ontology and domain set concepts and applied ontology as software artifacts in the software process and technologies.

The book has been written for postgraduate students, software engineering researchers and university professors. The book has more than three authors (and several contributors for some chapters). Therefore, the contents have been developed based on the academic standards for use in papers and journals rather than industrial standard that are easy to digest and follow.

The first chapter is about the Ontological engineering principles, methods and tools. In chapter two and three the authors introduces using ontology in software engineering & technology and engineering the ontology for the SWEBOK (Software Engineering Body of Knowledge).

In the following chapters there are many interesting proposals and approaches including software maintenance ontology and ontology for software measurement. In chapter seven, there is an ontological approach to SQL: 2003 that is interesting to study and follow.

Meta-model and general structure of meta-models are introduced and reviewed in chapters eight and nine. In chapter ten, the authors approach the use of Ontologies in software development environment. Sadly this chapter is a little outdated.

Chapter eleven which is "Semantic Upgrade and Publication of Legacy Data" is an interesting chapter with useful information and many good illustrations.

The first chapters are very useful as an introduction to Ontological engineering. Chapters five to eleven are really for those who are competent in ontology and software engineering but are looking to discover more.

Tip
This book is an excelent way to introduce yourself to a new area about conceptual understanding by using Ontologies as a tool.
... Read more

Product Description

Written for those who want to develop their knowledge of requirements engineering process, whether practitioners or students.

Using the latest research and driven by practical experience from industry, Requirements Engineering gives useful hints to practitioners on how to write and structure requirements.  It explains the importance of Systems Engineering and the creation of effective solutions to problems.  It describes the underlying representations used in system modeling and introduces the UML2, and considers the relationship between requirements and modeling.  Covering a generic multi-layer requirements process, the book discusses the key elements of effective requirements management.  The latest version of DOORS (Version 7) - a software tool which serves as an enabler of a requirements management process - is also introduced to the reader here.

Additional material and links are available at: http://www.requirementsengineering.info

Customer Reviews (2)

Practical application
I work in a large financial institution with projects that span across lines of business. I train on process improvement and requirements is one of the key areas I focus on. This book is short and to the point. It provides good examples and is a great read for someone who is just starting out in requirements management or requirements documentation. It provides information on the management aspects of requirements work and practical advice on requirements ellicitation.

Excellent !
This book presents in the space of some 200 pages, split into 9 chapters, a clear and concise introduction to a state-of-the-art approach to requirements engineering (RE). It starts out by introducing a generic RE process, which is then instatiated, later in the book, into concrete processes for generating stakeholder requirements (i.e. user requirements) and system requirements.

The beautiful thing aboout this generic process (and the concrete ones to follow it) is that V&V and change management are intrinsically part of it. The authors are particularly strong in their treatment of traceability. They have gone into an unusual depth. The book has some good advice on writing better requirements . In particular, I find the idea of requirements boilerplates (i.e. templates for each class of requirements) extremely useful. The book concludes with an introduction/demonstration of the DOORS RE tool, from Telelogic (the affiliation of two of the authors).

Overall, this is an excellent book that every requirements engineer, should have on their desk. ... Read more

Product Description

Solid requirements engineering has become increasingly essential to improved on-time and on-budget delivery of software and systems projects. As more engineering programs make it a mandatory part of their curricula, students and working engineers require significant training to master the field, especially the complicated emerging ancillary software tools vital to the requirements engineering process.

Apply Learning to Better Understand Applications

With an intentional focus on software-intensive systems, Requirements Engineering for Software and Systems provides a probing and comprehensive review of the state of technology and developments in intelligent systems, soft computing techniques, and their diverse applications in manufacturing.

Topics covered can be applied to the requirements engineering practices for—

• Advanced production machines and systems
• Collaborative and responsive manufacturing systems
• Digital manufacturing
• E-manufacturing
• E-business and virtual enterprises
• Fit manufacturing
• Human machine interfaces
• Innovative design technologies
• Intelligent and competitive manufacturing
• Intelligent planning and scheduling systems
• Mechatronics and MEMS
• Micro and nano manufacturing
• Production automation and control
• Reconfigurable manufacturing systems
• Robotics
• Sustainable manufacturing systems

Real-World Examples Inform and Clarify Theory
To illustrate key ideas associated with requirements engineering, the text presents three common example systems: an airline baggage handling system, a point-of-sale system for one location of a large pet store chain, and a system for a "smart home" in which one or more PCs control various aspects of the home’s functions. The selected systems encompass a wide range of applications—from embedded to organic, for both industrial and consumer uses.

Customer Reviews (1)

An essential reference for any software engineer
Anyone can write software, but it takes an engineer to make it robust and well designed... this book teaches just that!

It starts off with a thorough introduction to Requirements Engineering. It walks you through the process of communicating with the customer, eliciting, analyzing, validating, modeling, and managing requirements. There is even an entire chapter on writing the requirements documents. The appendix includes a sample requirements specification.

If you are serious about learning this, like I was, I would definitely recommend this book. ... 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
For more than a decade, Steve McConnell, one of the premier authors and voices in the software community, has helped change the way developers write code--and produce better software. Now his classic book, CODE COMPLETE, has been fully updated and revised with best practices in the art and science of constructing software. Whether you're a new developer seeking a sound introduction to the practice of software development or a veteran exploring strategic new approaches to problem solving, you'll find a wealth of practical suggestions and methods for strengthening your skills. Topics include design, applying good techniques to construction, eliminating errors, planning, managing construction activities, and relating personal character to superior software. This new edition features fully updated information on programming techniques, including the emergence of Web-style programming, and integrated coverage of object-oriented design. You'll also find new code examples--both good and bad--in C++, Microsoft(r) Visual Basic(r), C#, and Java, though the focus is squarely on techniques and practices. ... Read more

Customer Reviews (124)

Great Book
Well, I haven't finished reading the book, but I'll update this review later. I'm a college student on 3rd year. I've done a few freelance jobs, some went well others not that much. While reading this book, I remembered all my good jobs as well as my bad ones. Probably that's why I love this book so much I've pretty much it makes me realize my mistakes, and teaches me how to do it correctly, right now I'm doing a personal project in which I'm also applying what I'm reading, so this book has become pretty handy. I don't think is a bible or something like that. But it guides you really well, in a lot of aspects of programming.

Should be required reading
I do feel that this should be required reading for anybody serious about doing software development.If you are a junior programmer or fresh out of college, I don't really care what you know (or think you know) you should read this book cover to cover.If you are a more advanced you can still find some value in it or at least show it to the junior programmers and tell them that you aren't the only person who cares about variable names :)

I just felt this really reminded and enforced the idea that software craftsmanship is worth spending some time on and quality code/coding standards make life easier for everybody.

A must-read for every programmer
The focus of Code Complete is software construction, i.e. the coding part of software development. As Steve McConnell notes in the preface, "construction is the only activity that is guaranteed to be done". You can skip almost any step (requirements, testing etc), but if you don't write any code there is not going to be any software.

I bought my copy of the first edition of Code Complete in 1997, and I was immediately fascinated. I had never read anything like it before - a book that concentrated on the actual writing of the code. For example, it had a whole chapter on if- and case-statements, and another chapter on the naming of variables. I had no idea there was so much to learn about these seemingly straight forward activities. It was immediately useful to me, and I started to apply as much as I could of what I learnt from it.

Although it concentrated on coding, it covered a broad spectrum of activities around coding, from requirements and design to testing, debugging and optimization. It also had a great reference section with suggestions of further reading in the area of software engineering. This became my starting point for finding lots of other good books to read, like Peopleware: Productive Projects and Teams (Second Edition) and Programming Pearls (2nd Edition).

So this summer I decided to re-read this seminal book, partly to see what's new in the second edition, and partly to see if still think it is such a great book.

To answer my own question - yes, it is still the number one book on writing code. It is near encyclopaedic in its coverage of the nuts and bolts of programming. There are chapters on the naming of variables, on organizing straight-line code, on conditionals, on loops, on lay-out, on good commenting and on how to write good methods.

In it, there are frequent references to scientific studies that support the advice given in the book. For example, how long should variable names be? Instead of just giving us his opinion, McConnell summarized the findings of several scientific studies on the subject.

Each time there is reference to a study, there is a little "hard data" symbol in the margin. There are other symbols in the margin as well, "Coding Horror" for code examples of what not to do, and "Key Point" for, well, key points. The margin is also used for cross references to other chapters, and for quotes related to the subject discussed. For me, this works really well. It is both useful and makes the text easier to read. In general, the book is very well laid out.

Some of my favourite advice from the book (all of which I remember from reading the first edition) are:

Chapter 7.1 Valid Reasons to Create a Routine - for example: Reduce complexity, Introduce an intermediate understandable abstraction, and Avoid duplicate code (there are 6 more valid reasons in this chapter). The second part of the chapter is called Operations That Seem Too Simple to Put Into Routines and contains a great example of why it can be good to put even a one-line calculation in a routine - the code becomes more readable, and small operations tend to turn into larger operations.

Page 172 (and 264 for variables) Use opposites precisely. When naming "opposite" methods and variables, be careful to use the correct pairs, like add/remove, begin/end, create/destroy etc. This makes the relationship between them clear and obvious.

Page 433 Break complicated tests into partial tests with new boolean variables. This is such a simple thing, but it makes the code a lot more readable.

Page 754 "Make the incompleteness of a statement obvi". For example, when breaking up a logical and over two lines, end the first line with && - that way, it is clear that the statement continues on the next line.

Even though the book truly is great, there are a few things to complain about. In the first edition, the chapters on layout and comments came right after the chapters on the different control structures. But in the second edition, these two chapters have been moved further back. To me, that doesn't make sense, since they too are related to how you actually write your code. Now there are chapters on testing, debugging, optimization and refactoring in between.

And talking about refactoring: while this is an important subject, I don't feel the chapter on refactoring is particularly good. This chapter is new in the second edition. The summary of refactoring is OK, but a good part of the chapter consists of just listing different kinds of refactorings.

Overall though, the second edition is a nice face lift. The code examples are now mostly in Java, C++ or Visual Basic (in the first edition they were in Pascal, C or Ada). But since all the major themes of the book were already present in the first edition, it does not make a big difference if you happen to read the first edition instead of the second edition.

Code Complete is thick - 862 pages (not counting the bibliography and index). If that feels like a lot to read, then I suggest you start by just reading one or two chapters, for example "Using Conditionals" or "Layout and Style". They (and pretty much any chapter in the book) can easily be read without first reading the preceding chapters, and these will give you a sense of what you can expect from the other chapters. Even if these are all you read, you will still get a lot of value from the book.

However, if you are a programmer and care about how you write code, you owe it to yourself to read the whole book. It is considered by many (including me) to be the best book available on programming, and it will almost certainly make you a better programmer. Highly recommended.

Code Complete: A Practical Handbook of Software Construction
The book was in perfect conditions, it arrived before the dead line they gave me.

Required Reading
I was told this was a classic, must read for every programmer. I found that it is a classic, must-read that no programmer should be without. ... Read more

Product Description
This book is intended to be a reservoir engineering book for college students, but itÂ’s not the usual college text book. It is a modern and very practical guide offering reservoir engineering fundamentals, advanced reservoir related topics, reservoir simulation fundamentals, and problems and case studies from around the world. It is designed to aid students and professionals alike in their active and important roles throughout the reservoir life cycle (discovery, delineation, development, production, and abandonment), and in the various phases of the reservoir management process (setting strategy, developing plan, implementing, monitoring, evaluating, and completing).



Benefits & Features:



The authors bring to this book their life-long experience and expertise in reservoir engineering and simulation techniques and practice. The goal is to present a comprehensive book, starting from basic principles and leading to real-life reservoir management aided by simulation. This practical book explores the functions of reservoir engineers, and how they analyze, think and work in real life situations. It presents:



• Rock and fluid properties, fluid flow principles, well test analysis, and reservoir performance analysis techniques.



• New topics such as reserves, reservoir economics, risk and uncertainties, probabilistic methods, and recovery processes.



• Role of reservoir simulation models in enhancing basic reservoir engineering concepts and practice.



Computer-based tools, including reservoir simulation, are used extensively in this book to illustrate various concepts related to reservoir engineering. Finally, the book offers class projects where the students can apply what they have learned to treat their problems. This book will serve the students and the industry well. ... Read more

Customer Reviews (3)

Good Comprehensive Book
This one delivers as promised.Comprehensive, detailed, and easily read.I wish I had this book 25 years ago.

Excellent
I am a Measurement/Logging While Drilling Field Engineer. I am Planning going for My Msc In Petroleum Engineering and have been studying. With this Book at my Disposal, I have being able to integrate higher Percentage of my Feild Knowledge and the Theoretical Expect of the field Of Engineering. This Book is the Master Piece. Don't Think Twice when u Want to Buy this Book. You will love it. Very explicit and Direct to the Point.

The Encyclopedia.
I'm a Chemical Engineering student and I was required to purchase this book for a masters level course (I'm still going for a Bachelors). This book is great, it is widely considered as the encyclopedia for Petroleum Engineering and it was only published a few months ago. Great book, everything is explained in here and there are plenty of examples. ... Read more

Product Description

Job titles like "Technical Architect" and "Chief Architect" nowadays abound in the software industry, yet many people suspect that "architecture" is one of the most overused and least understood terms in professional software development.

Gorton's book helps resolve this predicament. It concisely describes the essential elements of knowledge and key skills required to be a software architect. The explanations encompass the essentials of architecture thinking, practices, and supporting technologies. They range from a general understanding of software structure and quality attributes, through technical issues like middleware components and documentation techniques, to emerging technologies like model-driven architecture, software product lines, aspect-oriented design, service-oriented architectures, and the Semantic Web, all of which will influence future software system architectures.

All approaches are illustrated by an ongoing real-world example. So if you work as an architect or senior designer (or want to someday), or if you are a student in software engineering, here is a valuable and yet approachable source of knowledge.

"Ian's book helps us to head in the right direction through the various techniques and approaches... An essential guide to computer science students as well as developers and IT professionals who aspire to become an IT architect". (Anna Liu, Architect Advisor, Microsoft Australia)

Customer Reviews (6)

Good solid book on software architecture
This book was the textbook for a introduction course to software architecture.I found the textbook quite helpful in learning architectural principles.

The core chapters of the book are the first 6 chapters, which provided a strong foundation of knowledge.Chapter 1 introduces the topic by discussing architecture definition, abstraction, views and non-functional requirements plus others.Chapter 2 introduces the study study utilized throughout the book.I got alot out of chapters 3 & 4.Chapter 3 discusses software quality attributes that an architecture should take into consideration.Quality attribute are characteristics of an architecture design rather than capability.Quality attributes are such items as scalability, modifiability, security, performance, portability, etc.Chapter 4 discusses architecture design patterns and technologies applicable to architecture design. Chapter 5 discusses development cycle for defining your software architecture.Chapter 6 discusses how to document the architecture design.

I thought chapter 6 was a bit light in discussing architecture documentation.In the course where this book was the textbook, there was much time spent discussing views and viewpoints.I think chapter 6 should have delved deeper into the view discussion.

I thought the author did an excellent job with this book.There are many different types of software architectures that can be built.Therefore, readers would becoming various technological perspectives in reading this book.I felt he discussed the topics in the chapters in a way that was applicable to this wide audience.

Complex and Useful
I found the subject matter of the book to be complex in a conceptual manner. Designing large systems is not simple because of the interaction between all of the subsystems that inter-relate to make the system work.I think the information is well worth the read because all good knowledge comes from cognitive work.I personally found that the best way to read this book was to relate that topicsthat were being discussed with a project that I was working on while using the example case as an added source of cognition.

I feel that this is an incredibly useful resource for those who have to design systems from the "ground up".It has several best practices and examples of where things can go wrong.

I feel this is well worth a read.

This book was not for me...
I initially wrote a far more acerbic review that got some feedback from the author, after ruminating on it for a while I figured I should edit it to express the direction my opinion veered after our discussion. I can't change the number of stars in the editing interface, but I'm not sure I should -- this book is not for me :)

One point of confusion emerged in our conversation -- the book appears to have been originally titled "Essential Software Engineering", and the author refers to it as such. Though I feel that in it's present form it would be quite inadequate as an engineering book, as an architecture book it is actually pretty damn good.

Much of the book is spent explaining different terminology well enough for the reader to be able to hold their own in conversation, but if everyone read the book (and did not do further research) there wouldn't be much discussion to be had. It's definitely an introductory text, not a primary source.

One thing that grated on me is that the book is mostly in nested outline form! The concepts are *well described*, but not too well contrasted. The format does not do a very good job of relating the concepts to one another -- they are presented serially as if in PowerPoint. You'd get a better understanding in a lot of ways by browsing the related Wikipedia articles, simply because hypertext is better suited for explaining multidimensional things (though hypertext obviously does not work on paper). A lot of the subheadings throughout the book are short & shallow -- but the alternative of longer & shallower would be clearly worse :)

The case study is discussed far too abstractly: he enumerates the functional and non-functional requirements, and gives an overview of the chosen architecture at too high of a level -- but does fairly little to justify the choices made. He does not really discuss the various downsides to the chosen architecture, nor does he discuss why other architectures were not chosen. Absolutely no discussion is made of feedback from the 'architect' to the 'client' about weighing the potential usefulness of the dictated features -- especially those which hinder the use of architectures better suited to the problem domain.

A major disappointment that stood out for me was that he didn't really address the *culture* of Big Design Up Front -- where all your mistakes are designed, diagrammed in UML, and ossified well before you start coding. I find that architecture should be something that is put off right up until the point when a qualitative decision about how things should work is no longer avoidable. My favorite definition of Software Architecture is from the original c2 wiki:

>"the set of decisions that we have to live with for the life
> of the project or system because it will be too expensive to
> change our implementation later if we change our minds"

Most of the technologies are related to the use of middleware to interface a companies' homegrown software and customized versions of commercial software together with commercial backend software. Because of this the primary readership I see for this book is in department-level managers in charge of dealing with the nightmare of deploying 'Enterprise Software' for a large business. I can see this book actually being quite helpful to them, particularly if they do not have a background in Computer Science.

If you're a code monkey and not a decision maker, this book doesn't really contain anything that could help you deal with your task directly -- it might even demoralize you by helping you realize how poorly/over-architected the system you toil on is. If you have any agency it might help you manipulate the managers below and above you into seeing things your way!

If you're an academic, it's probably only really useful for 'gawking at the natives' over in industry. Much of the chafing that I experienced with this book is related to the fact that my course spent 3 credit-hours a week on it for ten weeks -- it did not hold up well at all under our drawn-out usage of it. We were not at all the right audience for it.

Reading through it again now it holds up a lot better, with a lot more mindfulness evident in the text than on the first drudgery-filled pass as a group. Thinking about it now I realize how exceptionally mindful it is for a book in it's field! I would not recommend it's use in an academic Computer Science course, but it would probably work pretty well as a text in courses on Business, Information Systems, or Software Engineering; especially in a coursework-based masters program.

The second edition promises to dismiss most of my criticisms, especially in regards to the case study.

See UML 2 applied to architecture specification
Get this book if you're interested in seeing UML 2 applied to software architecture specification. In any case, it gives a good overview of architecting with emerging technologies as well as state-of-the-industry middleware.

Practical and timely
My Master's project deals with Software Architecture best practices and I turned to this book to help formulate my thoughts. The chapter on Middleware architectures is a valuable read and serves as a unifying framework for thinking about middleware in the architectural sense. The case study used in the book is helpful as well. Overall, you will find this book an excellent introduction to Software Architecture (with a nice dive into middleware and other topics not readily found in other SA books) and a nice read to go along with the other Software Architecture classics from the SEI. ... Read more

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
Proceedings of the First International Workshop on Agent-Oriented Software Engineering, AOSE 2000, held in Limerick, Ireland, on June 10, 2000. The text serves a comprehensive overview of agent-oriented software engineering, addressing software engineers and research and development professionals. Softcover. ... Read more

Customer Reviews (1)

Not good
This is basically a compilation of various published works on AOSE, some good, some bad.
All the good ones are available via ACM anyway.
... Read more

Product Description
Papers from the Second Intl Workshop, AOSE 2001, held May 29, 2001 in Montreal, Canada. Offers sections on societies and organizations, as well as protocols and interaction frameworks. Softcover. ... Read more

Product Description
Scandal! Corruption! Software engineering?

Industry experts Johann Rost and Robert L. Glass explore the seamy underbelly of software engineering in this timely report on and analysis of the prevalance of subversion, lying, hacking, and espionage on every level of software project management. Based on the authors' original research and augmented by frank discussion and insights from other well-respected figures, The Dark Side of Software Engineering goes where other management studies fear to tread -- a corporate environment where schedules are fabricated, trust is betrayed, millions of dollars are lost, and there is a serious need for the kind of corrective action that this book ultimately proposes. ... Read more

Product Description
Beginning with a basic primer on reverse engineering-including computer internals, operating systems, and assembly language-and then discussing the various
applications of reverse engineering, this book provides readers with practical, in-depth techniques for software reverse engineering. The book is broken into two parts, the first deals with security-related reverse engineering and the second explores the more practical aspects of reverse engineering. In addition, the author explains how to reverse engineer a third-party software library to improve interfacing and how to reverse engineer a competitor's software to build a better product.
* The first popular book to show how software reverse engineering can help defend against security threats, speed up development, and unlock the secrets of competitive products
* Helps developers plug security holes by demonstrating how hackers exploit reverse engineering techniques to crack copy-protection schemes and identify software targets for viruses and other malware
* Offers a primer on advanced reverse-engineering, delving into "disassembly"-code-level reverse engineering-and explaining how to decipher assembly language ... Read more

Customer Reviews (20)

Does not include 64-bit processors and OSs
I was disappointed that a book of this type does not cover 64-bit computing.

I've had a 64-bit CPU in my PC since 2003 so it should have been included here.

I don't think you can even buy a non-64-bit processor nowadays.Maybe a second edition could include this ?

Otherwise, it is a good book.

Good
The book was shipped to my country two weeks earlier. Was in a good condition (new) and I'm very satisfied with my purchase. Thanks.

Pure perfection.
I am sorry for having written this review so late. This book is a true gem; a must-have for any serious software engineer. Understanding how software works under the hood is key to writing code properly -- and this book provides an insight on that topic in an absolutely BRILLIANT MANNER.

Having a fair bit of reverse engineering experience myself, I have found this book to be extremely concise and detaild -- and I have learned a fair bit of new material while reading it.

There is no dull moment in this book. The author (who is clearly a gifted writer) explains reverse-engineering-related topics in a fascinating and unique manner, and, within this work, he actually cements the way in which reverse engineering should always be taught. Written by a true master, the book is very pedagogic; every chapter is accompanied by detailed examples -- which make the discussed topics crystal-clear.

I would have given this book more than five stars, had I been able to -- and I can recommend it to every software deveopler without a trace of hesitation; actually, it is now that I have bought an additional copy as a gift to a friend. Rest assured that this book will be a crucial part in your collection of tech books, just like it is in mine.

To sum it all up (and as it becomes clear from the above written): I think that this book is a magnificent work of art (no less), and I would even dare to say that I enjoyed it more than any tech book I ever owned. With all the aforementioned complements and my vain attempts to describe the magnificence of this work, words still can't fully do justice to this book. HIGHLY RECOMMENDED.

Mainly for Microsoft Windows
Book has some good concepts, but most all the book is specifically for Microsoft Windows tools and techniques.I would have like more general approach for various architectures and operating systems.

Good book
I learned a lot from this book. Some things are a little over my head but that keeps me challenged. This book breaks down the Windows OS very well. ... Read more

Product Description

This book offers an easily accessible foundation to the topic of software engineering. It focuses on the essential elements, providing the reader with the basic skills and knowledge required to execute a software project successfully.

Following the winning formula and easy-to read style of the author’s previous An Integrated Approach to Software Engineering, this reader-friendly text is written especially for undergraduates as an introduction to this broad-ranging discipline. With a strong emphasis on practice, this textbook takes a case-study approach whereby a project is developed through the course of the book, illustrating the different activities of software development. The sequence of chapters is essentially the same as the sequence of activities performed during a typical software project.

Designed for undergraduates and bolstered with numerous examples and chapter summaries, this text imparts to the reader the fundamental knowledge, skills, practices and techniques within software engineering.

Product Description

For over a decade, software process improvement (SPI) has been promoted as an approach to improve systematically the way software is developed and managed. Mostly this research and the relevant experience reports have focused on large software companies. This book collects the main results from four Norwegian industrial research and development projects on SPI carried out between 1996 and 2005. It concentrates on small and medium-sized companies, typically characterized by fast-changing environments.

Customer Reviews (1)

Software Process Improvement experience
Our organization is evaluating software process improvement and this book provided some interesting insight based on experience that proved useful.
Implementing these processes to improve can be difficult, but knowing where the pitfalls helps. This book provides steps, operational recommendations, focus on small and medium sized enterprises, knowledge management and other areas useful to researchers, graduate students, and software professionals. The book has a basis on research by the thought leaderssuch as Basili, Juran, Boehm and others to name just a few.
... Read more

Product Description
Software Reliability Engineering is the classic guide to this time-saving practice for the software professional. ACM Software Engineering Notes praised it as: ".an introductory book, a reference, and an application book all compressed in a single volume.The author's experience in reliability engineering is apparent and his expertise is infused in the text." IEEE Computer noted: "Toward software you can depend on.This book illustrates the entire SRE process.An aid to systems engineers, systems architects, developers, and managers." This Second Edition is thoroughly rewritten for the latest SRE practice, enlarged 50%, and polished by thousands of practitioners. Added workshops help you apply what you learn to your project. Frequently asked questions were doubled to more than 700. The step-by-step process summary, software user manual, list of articles of SRE user experience, glossary, background sections, and exercises are all updated, enhanced, and exhaustively indexed. To see the Table of Contents and other details, click on http://members.aol.com/JohnDMusa/book.htm ... Read more

Customer Reviews (1)

Book Contents
The "search inside this book" feature was not available when this review was posted. Hope it helps.

Contents
Acknowledgments
How to use this book

Chapter 1 - Problem, Process, and Product
1.1 Core material
1.1.1 Problem and solution
1.1.1.1 What is the software practitioner's biggest problem
1.1.1.2 How does software reliability engineering approach it?
1.1.1.3 What's been the experience with SRE?
1.1.2 The software reliability engineering process
1.1.3 Defining the product
1.2-1.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 2 - Implementing Operational Profiles
2.1 Core material
2.1.1 Developing operational profiles
2.1.1.1 Identifying the initiators of operations
2.1.1.2 Creating the operations list
2.1.1.3 Reviewing the operations list
2.1.1.4 Obtaining occurrence rates
2.1.1.5 Determining occurrence probabilities
2.1.2 Applying operational profiles
2.2-2.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 3 - Engineering "Just Right" Reliability
3.1 Core material
3.1.1 Defining "failure" for the product
3.1.2 Choosing a common measure for all associated systems
3.1.3 Setting system failure intensity objectives
3.1.3.1 Determining user needs for reliability and availability
3.1.3.2 Determining overallreliability and availability objectives
3.1.3.3 Finding the common failure intensity objective
3.1.4 Determining developed software failure intensity objectives
3.1.5 Engineering software reliability strategies
3.2-3.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 4 - Preparing for Test
4.1 Core material
4.1.1 Preparing test cases
4.1.1.1 Planning number of new test cases for current release
4.1.1.2 Allocating new test cases
4.1.1.3 Distributing new test cases among new operations
4.1.1.4 Detailing test cases
4.1.2 Preparing test procedures
4.2-4.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 5 - Executing Test
5.1 Core material
5.1.1 Planning and allocating test time for the current release
5.1.2 Invoking test
5.1.3 Identifying failures
5.1.3.1 Analyzing test output for deviations
5.1.3.2 Determining which deviations are failures
5.1.3.3 Establishing when failures occurred
5.2-5.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 6 - Guiding Test
6.1 Core material
6.1.1 Tracking reliability growth
6.1.1.1 Estimating failure intensity
6.1.1.2 Using failure intensity patterns to guide test
6.1.2 Certifying reliability
6.2-6.6 Exercises, Workshop, Special situations, Background, FAQ

Chapter 7 - Deploying SRE
7.1 Core material
7.1.1 Persuading your boss, your coworkers, and stakeholders
7.1.2 Executing the deployment
7.1.3 Using a consultant
7.1.3.1 Understanding the consultee's viewpoint
7.1.3.2 Understanding the consultant's viewpoint
7.2-7.6 Exercises, Workshop, Special situations, Background, FAQ

Appendix A - The SRE Process, Step by Step
Appendix B - Glossary
Appendix C - Summary of Useful Formulas
Appendix D - Using CASRE Software
D.1 Core material
D.1.1 Creating the failure data file for CASRE
D.1.2 Executing CASRE
D.1.3 Executing CASRE with Excel to Obtain FI / FIO Plots
D.1.4 Interpreting CASRE results
D.2-D.4 Exercises, Special situations - troubles, FAQ
Appendix E - Exercise Solutions
Appendix F - User Experiences with SRE
References
Index

More detailed contents and information can be obtained on the author's website at http://members.aol.com/JohnDMusa5/book3.htm ... Read more