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

Customer Reviews (64)

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

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

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

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

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

A project leader should have it in his desk.

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

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

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

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

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

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

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

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

Product Description
Software components are increasingly central to efficient, cost-effective software development. In this book, the world's leading experts on component software development come together to present the field's state of the art, and to offer new insights into the key challenges of component architecture and reuse. With original contributions by leaders such as Ivar Jacobson, Martin Griss, Len Bass, Paul Clements, Don Reifer, and Will Tracz, this carefully edited book is the "first word" on components: a tool for helping practitioners get the most out of all their component-based resources. It offers new insight for deciding whether and how to implement component-based development strategies; as well as a clear understanding of the obstacles to successful component development, and "best practices" responses. The contributors review diverse approaches to component development, present state-of-the-art processes for building component-based systems, and introduce new research directions that will impact component development in the coming decade.For software developers, designers and architects; business analysts; technology executives; computer science and software engineering researchers; project managers; QA specialists, and other professionals. ... Read more

Customer Reviews (4)

Book Articles
The "Search Inside this Book" feature was not available when this review was posted. This book contains the following (excellent) articles:

TABLE OF CONTENTS

I. COMPONENT DEFINITON.
1. Definition of Software Component and its Elements.
George T. Heineman, William T. Councill.
2. The Component Industry Metaphor.
Hedley Apperly.
3. Component Models and Component Services: Concepts and Principles.
Rainer Weinreich, Johannes Sametinger.
4. An Example Specification for Implementing a Temperature Regulator Software Component.
Janet Flynt, Jason Mauldin.

II. THE CASE FOR COMPONENTS.
5. The Business Case for Software Components.
John Williams.
6. COTS Myths and Other Lessons Learned in Component-Based Software Development.
Will Tracz.
7. Roles for Component-Based Development.
Paul Allen.
8. Common High Risk Mistakes in Component-Based Software Engineering.
Wojtek Kozaczynski.
9. CBSE Success Factors: Integrating Architecture, Process, and Organization.
Martin L. Griss.

III. SOFTWARE ENGINEERING PRACTICES.
10. The Practice of Software Engineering.
George T. Heineman.
11. From Subroutines to Subsystems: Component-Based Software Development.
Paul C. Clements.
12. Status of CBSE in Europe.
Barry McGibbon.
13. CBSE in Japan and Asia.
Mikio Aoyama.

IV. THE DESIGN OF SOFTWARE COMPONENT INFRASTRUCTURES.
14. Software Components and the UML.
Kelli Houston, Davyd Norris.
15. Component Infrastructures: Placing Software Components in Context.
Steve Latchem.
16. Business Components.
James Carey, Brent Carlson.
17. Components and Connectors: Catalysis Techniques for Defining Component Infrastructures.
Alan Cameron Wills.
18. An Open Process for Component-Based Development.
Brian Henderson-Sellers.
19. Designing Models of Modularity and Integration.
Kevin J. Sullivan.

V. FROM SOFTWARE COMPONENT INFRASTRUCTURES TO SOFTWARE SYSTEMS.
20. Software Architecture.
Alexander L. Wolf, Judith A. Stafford.
21. Software Architecture Design Principles.
Len Bass.
22. Product-Line Architectures.
Martin L. Griss.

VI. THE MANAGEMENT OF COMPONENT-BASED SOFTWARE SYSTEMS.
23. Measurement and Metrics for Software Components.
Jeffrey Poulin.
24. The Practical Reuse of Software Components.
Don Reifer.
25. Selecting the Right COTS Software: Why Requirements are Important.
Cornelius Ncube, N.A.M. Maiden.
26. Build vs. Buy: A Rebuttal.
George T. Heineman.
27. Software Component Project Management Processes.
William T. Councill.
28. The Trouble with Testing Software Components.
Elaine Weyuker.
29. Configuration Management and Component Libraries.
Hedley Apperly.
30. The Evolution, Maintenance and Management of Component-Based Systems.
Mark Vigder.

VII. COMPONENT TECHNOLOGIES.
31. Overview of the CORBA Component Model.
Douglas C. Schmidt, Nanbor Wang, Carlos O'Ryan.
32. Transactional COM+: Designing Scalable Applications.
Timothy J. Ewald.
33. The Enterprise JavaBeans Component Model.
David Blevins.
34. Bonobo and Free Software Gnome Components.
Michael Meeks.
35. Choosing Between COM+, EJB, and CCM.
Andy Longshaw.
36. Software Agents as Next Generation Software Components.
Martin L. Griss.

VIII. LEGAL AND REGULATORY.
37. CBSE as a Unique Engineering Discipline.
John Speed, William T. Councill, George T. Heineman.
38. The Future of Software Components: Standards and Certification.
Janet Flynt, Manoj Desai.
39. Commercial Law Applicable to Component-Based Software.
Stephen Chow.
40. The Effects of UCITA on Software Component Development and Marketing.
Stephen Chow.

IX. CONCLUSION.
41. Summary.
William T. Councill, George T. Heineman.
42. Future of CBSE.
William T. Councill, George T. Heineman, Jeff Poulin.
Appendix A. Glossary.
References.
About the Authors.

I hope this helps.

Encyclopedic and full of information
Covers the full spectrum of component-based software engineering, from the basics to legal aspects.Contains one of the most authoritative collections of essays and whitepapers on the subject between two covers.I have used this book as a basis for component-based development, and have also used it as the foundation for a SQA initiative because the material also addresses quality. Many of the essays support a software reuse strategy, which is an added bonus.Another use of this outstanding book is as a resource for in-house training in many aspects of software engineering outside of the component-based domain. It's that comprehensive and complete.I recommend using this book with Successful Software Development as the two primary references in mature development organizations.

A definitive reference on the subject
This 818 page collection of 42 papers and articles is a definitive work on component-based software engineering.Regardless of your area(s) of interest, there is probably a chapter that addresses it.More importantly, each chapter is written by a top expert in their subspecialty.

Instead of giving a chapter-by-chapter description, I am going to cover the chapters that I found useful.To begin, Part II, chapters 1 through 3 gave me a quick primer in software components and highlighted the need to think in a different frame when dealing with component-based development.If you are new to CBSW then the 48 pages devoted to the basics are worthwhile reading.

Part II's five chapters on making a business and technical case for components is outstanding and the authors cover every facet.I found Part III, which covers software engineering practices, particularly useful.The value to me was the status of CBSW engineering on a global scale because I am currently providing consulting services to an India-based company that specializes in components.For this reason I also found Part IV's eight chapters on managing component-based software systems especially valuable.

The real eye-opener [for me], however, was in Part VIII, which devotes four interesting chapters on aspects of legal and regulatory issues as they related to software development as a discipline, and component-based software engineering specifically.In particular, chapter 38 on software component standards and certification was enlightening. I was also enlightened by chapter 39's fascinating discussion on commercial law applicable to component-based software, and the effects of the Uniform Computer Information Transactions Act (UCITA) on component-based software development and marketing.

This is an excellent book that covers the entire landscape of component-based software engineering and, although is a weighty 818 pages, is not difficult to read through.Each chapter is really a paper or article, so each is standalone.If you are dealing with off-shore development in any way, the book is especially valuable, and if you are doing CBSW in-house, the key differences between this approach and other development approaches are highlighted and will give you sufficient information with which to approach CBSW intelligently and effectively.

Excellent Anthology
This book is an excellent collection of articles describing all of the important issues surrounding the construction of component-based software systems. Each chapter describes a different aspect of the question of how to build a system using reusable components. Although each of these chapters is written by a different author or authors, they have been edited so that they read as a continuous whole. It is interesting that the editors were able to get some of the biggest names in the field to write articles on their specialties. A look at the author biographies show that they include industry practitioners, academics, industrial researchers, and independent consultants. Together they have a very impressive amount of experience and varied expertise. Perhaps my only complaint is that because so many different topics are covered, and each article is rather brief, some of the articles just touch the surface of the issues. But they do provide a balanced picture of these issues which then allow you to go out and do further in-depth reading on salient topics using the included list of references. ... 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
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

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
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

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

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

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

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

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

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

Customer Reviews (51)

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

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

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

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

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

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

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

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

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

Recommended.

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

Product Description
This 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
Designed for beginning and intermediate C programmers, this bestselling book has received much acclaim for its highly readable presentation. While focusing on the C programming language, the book emphasizes stylistic issues and software engineering principles that can be applied to developing programs that are readable, maintainable, portable, and efficient. 64 illus. ... Read more

Customer Reviews (13)

Good at C language, average on Software Engineering
This book works fine as a textbook for use in class or for self study, but not as a reference. I transitioned from Fortran to C using this book more than a decade ago, and it worked well. Pretty soon, however, I was looking for more information on the C libraries elsewhere. While it gives an overall picture of the language and of what one can call "best programming practices" (which is good), it leaves out many details so important for the practicing programmer (wich is bad). Some of this is arguably outside the scope of the book, though.

The part on SW engineering gives a nice overview of the waterfall model of SW development, discusses each main phase of development, emphasizes the importance of the planning and the test phases of the project, and presents a case study in the final chapter. However, for an aspiring SW engineer it is a little thin in details, so you will have to look elsewhere for more "dirty"---and practical and modern---examples.

My rating: five stars for the very well, didactically written book with many examples and a consideration for SW engineering, and minus one star for the light treatment of some delicate topics, lack of more information on libraries other than the ANSI standard runtime, and the typos---many typos, of the annoying type (++i instead of i++, example programs with "example executions" that prints out different names and strings, etc.), but mostly harmless.

There are better...
Ther are better books available for learning C.This 1996 edition may have been great for the time, but frankly, I don't see how.While it's true that it does cover a lot of information, and does provide helpful tips to using C, it's also true that the book itself is poorly written (or poorly edited, which amounts to the same thing).Its only somewhat better than a collection of ideas that have been collected, collated, and dumped onto the press for publication.I finally got tired of trying to glean the nuggets from the dross and gave up reading it about 2/3 the way through.(I would have quit sooner, but I hoped I'd eventually get a feel for the authors style.)So..get 'C Primer +', or anything else.(K&R 2 is an essential read sooner or later..so why not now).But before buying this, try to find a copy to evaluate..who knows, you might be like the others who gushed over this book..on the other hand, it'd be sad if you found it to be like I did, but too late.

Great for learning or reference
Where the K&R book is terrible for learning C, this book makes it a snap.
It provides an organized and complete tutorial for the novice C programmer as well as a useful reference for the more experienced C user.

Its sad that this book is not world famous
As some one who took an unguided path into C programming, I can really appreciate how much of a difference this book would have made if I came across it earlier.

This book elegantly lays down the structure and parts of the C language. It presents the reasons behind various features of the language.

This is the book that will teach you to think about programming in an intuitive way.

Best single reference for using C - period.
The perfect balance of complete, useful information on ANSI C.All technical information (data types, operators, declarations, pointers, arrays) is there. It it all explained in sufficient, readable but not wordy detail.It is remarkable in its efficiency.

It's all in there - the preprocessor, railroad diagrams showing the syntax of each statement, code snippets where they useful.Data structures, starting with the bit datatype, then defining and explaining more advanced concepts of unions, structures, and the user-defined types using _typedef_.Then full examples tieing it together with linked lists, then doubly linked lists.

A brief section on software engineering concepts showing the importance ofdesign and test, and finally a complete working C interpreter.

What really sets it apart though is its complete reference of the most-used standard library functions - formatted and file I/O, string and memory manipulation functions.Effective use of the proven library functions is one of the marks of the software professional, and the outer framework of most useful real-life programs is getting data in and out.

The book begins with a very high-level overview of programs to establish its context, but this is NOT a how-to-program book. If you already understand the fundamental concepts (arithmetic and logical operations, looping) and you need a comprehensive book on how to use C, this is the one.There are lots of books in the "this is a reference, not a tutorial" class (e.g. K&R) and lots of wordy tutorials that never get to the difficult parts (like 'how do I pass a pointer to a multidimensional array.').This is one book that is sufficiently organized to be a reference, with enough clear explanation that you'll learn how and why things work.

I've had my 2nd edition of this book since it was new in 1991 and recently purchased a copy of the reviewed edition for a friend.It's still excellent, with improved coverage of new features and extensions, and removal of the obsolete adjective "new" when referencing the ANSI standard that's been ratified for a good long while now.

There is no mention of C++ - this is a C book.Good ol' ANSI C is still the language of choice for many if not most embedded projects, even new design.I believe a solid foundation in C will serve any C++ programmer well - under the 'object' layer of C++ lie member functions that actually do the work, and those functions look a lot like C...

Like most good technical books, this one's not cheap, but it's a quality Springer-Verlag binding on acid-free paper that will last a career if not a lifetime.And considering the depth, breadth, and clarity of the content, it is a bargain.

A must-have. ... 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
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
Often referred to as the "black art" because of its complexity and uncertainty, software estimation is not as hard or mysterious as people think. However, the art of how to create effective cost and schedule estimates has not been very well publicized. While the average software organization can struggle with project costs that run double their original estimates, some of the more sophisticated organizations achieve results with estimation errors as low as 5-10%. These best-in-class organizations use scientific techniques that are not cost-effective, however, making them of limited use to most software development organizations. To address these issues, Software Estimation focuses on the art of software estimation and provides a proven set of procedures and heuristics that software developers, technical leads, and project managers can apply to their projects. Instead of arcane treatises and rigid modeling techniques, award-winning author Steve McConnell gives practical guidance to help organizations achieve basic estimation proficiency and lay the groundwork to continue improving project cost estimates. This book is organized from simple tips to more advanced ideas; it does not avoid the more hairy mathematical estimation approaches, but the non-mathematical reader will find plenty of useful guidelines without getting bogged down in complex formulas. ... Read more

Customer Reviews (41)

Home Run
This book gives you evidence and common sense approach to the world of software estimation.You will finally understand the reasons you know inherently exist in estimations backed by facts.Thisbook takes the guess work out and real honest debate on actual impacting forces with scientific backing. This book is a must to any team struggling to meet software deadlines.

Really demystifying book
I bought the book more as a curiosity because I am very skeptical towards software estimation or anything that claims to be an "engineering" or "formal" approach on software management, because no matter what technique is used on the management side (from PMBOOK to the witchcrafted Agile), in the end someone come to us (developers) and says: "We need that for X" where X is a ridiculous and unrealistic schedule.

But, the book actually surprised me with good techniques and insights that I could transfer to me day-to-day mine-field tasks, specially when right in the beginning it states very clear the differences between estimatin and commitment.

Well, if someone will take my estimations more seriously from now on it is not my problem, but at least it helped to have them created based more on facts (and countable things) than just out of nowhere.

Hooray for the author!

If you estimate software cost and effort YOU MUST READ THIS
If you have been or will start estimating software, then you must read this book. You will be introduced to many different estimation techniques, albiet some at a high level.

However, if you are serious about truely developing software estimation as a professional skill the book is loaded with references and cites to many more sources which are very detailed in nature. It is worthwhile to start here and identify the technique(s) that will work best for your organization then get into the details of actually applying.

On a different note, this book does sum up to a subtle sales pitch of Construx estimating software, which the author of the book was a critical figure in creating. However, the sales pitch doesn't get in the way of you still learning alot about the field of sotware estimation.

I have re-read some chapters, particularly towards the back of the book, countless time.

Title is a little misleading
This book is full of statistical information. If you are already a software estimator, then this book will probably help you. However, the subtitle, "Demystifying the Black Art" seems, to me, to mean that the book will help you learn to do a software estimate. Not learn how to do it better, but learn how to do it, period. That is not what this book is about. It is about doing it better. If you already know the basics of function point or line of code estimation, then this book will probably help you make *better* estimates. However, if you want to learn the "black art of estimation", then this book will not demystify anything.

I think overall it is a good book, which is why I gave it three stars. However, it is very inappropriately titled. If you already know the basics of software estimation, then there is probably not any mystery for you. This book would have been better subtitled, "Enhancing the Black Art", or "Getting your black belt in Software Estimation".

I suppose that once I learn how to estimate software this book will be more beneficial.

required reading for everyone in the software industry
"Software Estimation" by Steve McConnell provides a very broad overview of many ways to reduce the software estimation errors for your development cycle. Like all of Mr McConnell's books, he provides crystal clear writing with tons of techniques that are ready for application in the real world.

One of the many great things about "software Estimation" is the sheer number of methods he gives. From Lines of code, to function points, to similar projects, to industry estimates (broken down by sub category so that database is different from embedded devices), to t shirt sizing, to maintaining development history: he makes it clear that you have a lot of different options available to you. He takes great pains to emphasize that one size does not fit all. Additionally he gives rationales for when the estimate techniques work in a project's lifecycle.

With all the methods described, another point driven home is that software is something of an art and that you can reduce the amount of uncertainty but you can never fully remove it. None of the methods that improve estimation are silver bullets. I love that he draws the line in the sand here. Its very true and in fact he goes a step further, pointing out that on successful projects the "cone of uncertainty" converges as the project matures. The converse is also true. Wise words indeed.

The final chapter feels more like a tack on, however the message contained therein is something that needs to be stated again and again: marketing/management is not the enemy. It is important to remember that everyone has the same goals and that the battle really should be a collaboration. However good this chapter was, it still felt out of place.

There are a few niggling issues that I had. The biggest gripe is that he talks a lot about estimation software packages. In fact, he makes assumptions that the reader has knowledge of these packages. Working in start-ups, I've never even heard of these packages until this book. Its a small gripe, but it did detract. Another issue would be some of the examples on applying the various techniques towards the end of the book were far too glossy and far to dry. I think there was some good information there but you, as the reader, will need to make a few assumptions. Which, to me, is always a dangerous thing. Not as bad as fighting a land war in Asia, but still dangerous.

Overall though, as a software engineer/manager I found this book to be invaluable. The techniques are usable right away and really helped me convey the uncertainty I had in ways that I wasn't able to in the past. I think this should be required reading for anyone who works in the software industry. ... 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
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