Product Description
Software Engineering: Principles and Practice challenges the reader to appreciate the issues, design trade-offs and teamwork required for successful software development. This new edition has been brought fully up to date, with complete coverage of all aspects of the software lifecycle and a strong focus on all the skills needed to carry out software projects on time and within budget. Highlights of the third edition include:
* Fully updated chapters on requirements engineering and software architecture.
* New chapters on component-based software engineering, service orientation and global software development.
* Extensive coverage of the human and social aspects of software development.
* Balanced coverage of both traditional, heavyweight development and agile, lightweight development approaches such as Extreme Programming (XP).

Written to support both introductory and advanced software engineering courses, this book is invaluable for everyone in software development and maintenance who wants an accessible account of the problems incurred in large-scale software development and the proposed solutions. A companion website with additional resources for students and instructors can be found at www.wileyeurope.com/college/van vliet ... Read more

Customer Reviews (5)

Unsatisfied
I never received the item.I don't know if the book was lost in the mail or if the sender never sent the book.

Good book for reference
Software Engineering Principles and Practice by Hans van Vliet is a good textbook which delves into the WHAT of software development, and takes a user through the normal Software Development Life Cycle (SDLC) from requirements gathering to deployment in a production environment. And like good software, each chapter is loosely coupled allowing the reader to get more information on the topic of interest.

This book however does not go into details on the HOW, and was left me a little unsatisfied on best practices, and how to improve my skills as a software engineer.

This book is great for students as well as professionals involved in Software Engineering. It gives students an overview of what to expect in a software shop, but is more of a reference book for professionals to give a little further insight into the different aspects of the SDLC.

Exactly what i was looking for
Having to teach on a new lab course on Software Engineering, i desperately looked for a book that helps me organize the topics i have to teach. Since i have a programming background , i was not so interested in the implementation part, but wanted to know more on the other aspects of the development : designing,testing,maintaining,assesing quality.This book made me look no further. It is a comprehensive book that covers all these aspects, and the case study that it contains it is not too complicated so it can capture the attention of an average student in a SW undergraduate course. In solving this case study the author does not bind himself to a single solution, but proposes and evaluates different architectures.From an educational point of view it is a good textbook

... and Practice???
Part of my work involves managing software projects, and leading teams of programmers and software engineers. I recently started my private holy grail search: I NEED to find a book that would advance my subordinates from programmers to leaders; from code-writers to application-makers. For this purpose, during the past year I have read many books - mostly software engineering ones.
As most SW engineers in my teams are university graduates, they already possess some theoretical knowledge in software enginering. What they lack is the know-how of translating theory into practice. Such wisdom is normally obtained after years and years of work (if at all). A good book enabling the engineer to climb faster up the learning curve and shorten this learning period would be invaluable to me.

Most SW engineering books teach theory, not practice. Thus, I approached this book named "Software Engineering: Principles AND PRACTICE " with great expectations. In short - I was very disappointed.
Not that it's a bad book. It is well written, and the theoretical part may serve well as a textbook, probably even aiding students to pass their SW engineering 101 course. However, I found the practical part of the book very lacking: No real tips. No real insights. Nothing really bright here. Definitely not something that would help somebody write better applications, produce high quality products on time, and eventually advance his/her career. NOT WHAT I AM LOOKING FOR.

Good coverage on principles and the of software engineering.
This is one of the better academic books I've seen in this area.It has the basic stuff you'd expect, but the author also presents very good discussions on writing software specs.The appendix includes some IEEEstandards on software documentation.A good book especially for softwareprofessionals and technical managers.

The section on softwaremaintenance is excellent and would be a good (and not-too-technical)resource for product managers, marketing managers, project managers, andthose involved with the software maintenance process -- something morecomplex and difficult than we usually think. ... Read more

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

Customer Reviews (5)

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

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

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

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

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

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

Carlos Ortega
2006-01-30

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

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

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

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

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

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

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

Product Description
Software Engineering with Microsoft Visual Studio Team System is written for a software team that is considering running a software project using Visual Studio Team System (VSTS). It is about the "why" of VSTS: its guiding ideas, why they are presented in certain ways, and how they fit into the process of managing the software lifecycle. This book is the next best thing to having an onsite coach who can lead the team through a consistent set of processes. It is a framework for thinking about software projects in a way that can be directly tooled by VSTS. It presents essential theory and practical examples to describe a realistic process for IT projects. This is a book that any team using or considering VSTS should read. ... Read more

Customer Reviews (9)

More about software project management than VSTS
"Team System" is a component of the Microsoft Visual Studio package designed to be used to manage the development of large software packages. It contains components to track bugs, set timelines, a change control system and all of the other functionality needed to establish the metrics and development data needed for the creation of a complex software package.
However, this book is really about software engineering, the inclusion of information about Team System is largely secondary to the main points of how software construction should be managed. The chapter headings are almost identical to those in other texts of software engineering. Starting with chapter three they are:

*) Requirements
*) Project management
*) Architectural design
*) Development
*) Testing
*) Reporting bugs
*) Troubleshooting the project

The material on software engineering is limited in depth, so if your goal is learning significant details on how to engineer software, this is not the book for you. In my opinion, the niche of this book is where a software shop is moving to Visual Studio as a development platform and the plan is to use Team System as well. Experienced developers will be able to understand all of the material, even when they lack previous exposure to the principles of software engineering.

Buy this book to sell your boss on VSTS
If you are a member or leader of a development team that has just ordered or installed Visual Studio Team System (VSTS), and are hungry to get started on your first VSTS project, this is NOT the book for you - as it isn't a "how to" manual on VSTS!

This book's intended goal is to be a solid, project manager-oriented, look at how to use VSTS to it's maximum advantage; and it attains that goal: you'll learn VSTS's tools and capabilities; and how to employ them to manage your software development efforts; but it is not intended to be an administrators guide on how to install, configure and debug the VSTS server or development environment(s).

To me, a major benefit of this book is that it is a great resource for selling your boss or upper management on the idea of initiating a pilot or "proof of concept" VSTS project - they will love the charts/graphs and reports that are shown in this book, and your "sales pitch" will benefit from the clear descriptions the author supplies as to how to read these charts or reports, and how to use them to keep yourself (and your superiors or clients) informed as to a project's status, and what bottlenecks or issues need to be addressed as the project progresses.

The text is relatively short - only 247 pages, which makes it a good weekend read - you aren't flooded with finicky details.

I also appreciated the "expected criticisms" section at the very end of the book: The author makes it clear that VSTS (at the time this book was written) is a brand new product, and will need a couple of releases to mature and reach its full potential.He also acknowledges that it will take time for a body of "field level" knowledge to accumulate as to how best to take advantage of innovations and technologies that are embodied in VSTS.

That awareness on the author's part, and the focus on why and how VSTS is designed to help you as a project manager, are what really help this book succeed: it will help you and your team be a more productive resource for your organization: building and delivering high quality software products on time and within budget using VSTS.

All in all, an excellent introduction to Project Management using Visual Studio Team System, and a book that will help you fully appreciate and exploit the capabilities and benefits of VSTS. 5 Stars!

Excellent Experience
This book is an excellent well of experience for budding project managers out there.It focuses on the "Why" and while short on the how, never pretends to be a 'how-to' book.I learned something from every chapter.

The First VSTS Book You Should Read
This book is a terrific high to mid level introduction to Visual Studio Team System, Microsoft Solutions Framework, and the overall philosophies and strategies behind Microsoft's ambitious undertaking. It provides terrific VSTS coverage, but it's also one the best overviews of modern software development approaches available today.

It's required reading for our instructors and mentors, and I recommend it to every one of our class and workshop participants.

Highly Recommended
Gives a nice peek into the "why" as opposed to the "how". I have read all the VSTS books that are out there right now and I appriciated this one very much. It was an easy read, but very informative. ... Read more

Product Description

Customer Reviews (17)

Book looks silly but is professionally on target
Notwithstanding the funny people and and fonts, the book provides much valuable information and advice on the development of serious IT applications.However I wish that it had more depth on how to develop Java classes.

Very good learning style
This book has a very good learning style. Good content. Helps to get you started in managing development time.

Great
The book was in the condition that it said and arrived on time. Great service.

Good for the new Team... but
I looked through this book online using Amazon and some of the pages looked of interest to me as I am working with some new teams who have not used Agile before and there were parts of this books (mainly around user stories) which got my attention.

I have been developing for 25 years and have been managing Agile teams over the last 4 years, recently using Scrum as the framework of choice. I was looking for some further material to expand my knowledge base and having read Head First Design Patterns (highly recommended) I thought this book would fit my needs.

For me, I was dissapointed. I read this book basically cover-to-cover in about 3 hours and there were aspects which made me think, on the whole there was nothing new in this book and the topics it did cover it did not go into any real depth. For me, not a good use of my money.

However, as a book to get my team and future teams who are new to Agile, Test First, Continuous Integration, Version Control, Unit Testing, User Stories, etc, this book is great and I do recommend it.

The Head First series of books take the reader on a simple journey. Nothing complex or where there is something complex they de-complex it and in some ways dumb it down to a reasonably low common-denominator. This means just about anyone can read this book and should understand the concepts and principles in it. I plan to provide this to some non-technical BA's who I work with and other than the section on Unit Testing know that they will be able to read this, digest it, and understand the principles and then hopefully use them within our organisation.

A Best Practice Book for Software Development
This book teach you best practices in today's software development industry. It should be a must read for any software development team member as well as project manager before the project kick off. ... Read more

Product Description
<>Praise for Software Test Engineering with IBM Rational Functional Tester

Customer Reviews (2)

Good training resource...
it's a very good training resource, for IBM certification in Rational Functional Tester. Besides, it's useful for reviewing tips for daily work.

Regards.

An automated read.
Well I awaited a few months for this book, it arrived just before Santa!

If you do not wish to pay for the courses available, then this book is by far the cheaper alternative.

It is well put together and easy to follow for beginners in the RFT automation field of software testing.

There are good chapters dedicated to building support for new objects and managing script execution. For a novice like myself, this book contained great insight to assist furthering my understanding of the tool. It also delivered in a clear and at a simple level. I found it easy to read, with good descriptions and explanations. Albeit some of the areas that are being described are not easy concepts. There is also good appendix on regular expressions and logging techniques.

It would have been nice to have had a story board project other than the classicjava. Code snippets are provided both in VB.Net and Java albeit on paper (you can get the download version).

On the whole I am impressed with the book and it has assisted my testing and I continually go back to it for reference. ... Read more

Product Description
Volume 1 of Software Engineering, Third Edition includes reprinted and newly authored papers that describe the technical processes of software development and the associated business and societal context. Together with Volume 2, which describes the key processes that support development, the two volumes address the key issues and tasks facing the software engineer today. The two volumes provide a self-teaching guide and tutorial for software engineers who desire to qualify themselves as Certified Software Development Professionals (CSDP) as described at the IEEE Computer Society Web site (www.computer.org/certification), while also gaining a fuller understanding of standards-based software development.

Both volumes consist of original papers written expressly for the two volumes, as well as authoritative papers from the IEEE archival journals, along with papers from other highly regarded sources. The papers and introductions of each chapter provide an orientation to the key concepts and activities described in the new 2004 version as well as the older 2001 version of the Software Engineering Body of Knowledge (SWEBOK), with many of the key papers having been written by the authors of the corresponding chapters of the SWEBOK.

Software Engineering is further anchored in the concepts of IEEE/EIA 12207.0-1997 Standard for Information Technology--Software Life Cycle Processes, which provides a framework for all primary and supporting processes, activities, and tasks associated with software development. As the only self-help guide and tutorial based on IEEE/EIA 12207.0--1997, this is an essential reference for software engineers, programmers, and project managers. This volume can also form part of an upper-division undergraduate or graduate-level engineering course.

Each chapter in this volume consists of an introduction to the chapter's subject area and an orientation to the relevant areas of the SWEBOK, followed by the supporting articles and, where applicable, the specific IEEE software engineering standard. By emphasizing the IEEE software engineering standards, the SWEBOK, and the contributions of key authors, the two volumes provide a comprehensive orientation to the landscape of software engineering as practiced today.

Contents:
* Key concepts and activities of software and systems engineering
* Societal and legal contexts in which software development takes place
* Key IEEE software engineering standards
* Software requirements and methods for developing them
* Essential concepts and methods of software design
* Guidelines for the selection and use of tools and methods
* Major issues and activities of software construction
* Software development testing
* Preparation and execution of software maintenance programs ... Read more

Customer Reviews (1)

Boring and Aweful
This book gets two stars because I got a B+ in the class, but this book is boring and painful to read. The words on the page feel useless as you read them. If you don't need this book for school, don't buy it. ... Read more

Product Description
Presents a comprehensive approach to improving the quality and effectiveness of the software development process. Author identifies scores of culture builders and culture killers. DLC: Software engineering. ... Read more

Customer Reviews (6)

More a catalog of ideas than a how to guide
This is a good book for software leaders who need ideas on how to improve the engineering culture in their organization.I thought the Culture Builders and Killers in each chapter were particularly useful.

A needed dose of software development sanity.
This is a great overview of all the elements of a successful software project - from project planning to system design on up to testing and project postmortem. Many of the topics are covered too lightly to allow apractitioner to use all of Wieger's advice right out of the gate. Butthat's fine - the book is meant to be a handbook of great ideas from whichpractitioners should choose, study and implement. Pay particular attentionto the discussion on determing project drivers and constraints during theproject planning phase - an area usually breezed over, with devastatingconsequences.

A must read for everyone in the software industry!
A practical guideline for building strong and successful software development methodologies.

Essential especially for small IS shops
Wiegers' experience in a relatively small group at Kodak and his practical approach embodied in this book provide sound and strong encouragement for anybody to improve their software processes. There may be no silver bullet, but this book comes awfully close.

A common-sense approach to software process improvement.
The book contains a common-sense approach to software process improvement strategies for most organizations to follow.Wiegers takes the mystique out of the Software Engineering Institute's CMM and offers the CMM as one way of many to accomplish process improvement.He balances technology and process-focus against real-world people issues.Must reading for anyone involved in a Software Engineering Process Group or for senior managers trying to figure out what all this stuff is about.Text is well illustrated by case studies and examples from the author's experience at Kodak ... Read more

Product Description

This book provides selective, in-depth coverage of the fundamentals of software engineering by stressing principles and methods through rigorous formal and informal approaches. In contrast to other books which are based on the lifecycle model of software development, the authors emphasize identifying and applying fundamental principles that are applicable throughout the software lifecycle. This emphasis enables readers to respond to the rapid changes in technology that are common today. Principles and techniques are emphasized rather than specific tools—users learn why particular techniques should or should not be used. Understanding the principles and techniques on which tools are based makes mastering a variety of specific tools easier. The authors discuss principles such as design, specification, verification, production, management and tools. Now coverage includes: more detailed analysis and explanation of object-oriented techniques; the use of Unified Modeling Language (UML); requirements analysis and software architecture; Model checking—a technique that provides automatic support to the human activity of software verification; GQM—used to evaluate software quality and help improve the software process; Z specification language. For software engineers.

Customer Reviews (5)

Excellent, but please consider that..
This book is an introduction to software engineering. It's an excellent book because it's a trade off between many things:

being comprehensive
being up to date
giving you the correct background and fundamental principles, on which every new trend is based
being short enough so students don't complain too much .


If you are a student you'll probably like it. If you are a professional that wants to self-learn software engineering, I would suggest instead "software engineering" of Ian Sommerville, ISBN 0137035152, that is constantly updated with the new trends.Ghezzi'sbook tends to give a more traditional view of the field.
The informations you receive from Ghezzi's bookwill probably be valid until the next decade; however, it's not a book for "a la mode" guys who like to follow the trends of the moment.

book for college for my son
thank you for having books...sometimes the college my son goes to doesn't get in enough textbooks for courses and Amazon.com is my family's way of assuring that he has a textbook.

Simply the best
Simply the best textbook on software engineering. Concise content and extensive coverage of most conventional SE topics. For students and practicioners who are interested in learning more than drawing simplistic diagrams.

Timeless
I bought my first copy of this text in 1992 and it has been my constant companion and mentor ever since. From my early Pascal days in college to J2EE development in present times, I have always found the authors' treatment of the discipline of software engineering to be concise, accurate and relevant to the issues at hand. It is one of those books that code shovellers hate...an uncompromising publication that addresses serious process issues such as requirements specification, rigour, interface design and modularity, and robustness. These matters just refuse to go away, and the authors of this book know it. This book is timeless.

Good
This book is in overall close to very good.Some confusingthings are the unclear differences of USE-relationship, and otherrelationships. I probably include more comments in the future. END ... Read more

Product Description
This book is designed to help software engineers and project managers to understand and solve the problems involved in developing complex software systems. It provides practical guidelines and tools for managing the technical and organizational aspects of software engineering projects.Part One explains the critical success factors for software, and introduces methods including:specification (using results-oriented quality and resource metricsfinding and evaluating solutioevolutionary planning and deliverinspection for quality and productivityPart Two gives detailed guidelines for implementing those methods, using a case study as an example throughout. Part Three shows in detail how the methods can improve productivity, reliability, estimation, deadline pressure, and motivation. It concludes with a set of 'Software Engineering Templates' showing how to quantify software qualities, and further case studies illustrating inspection experience and production planning. ... Read more

Customer Reviews (8)

Clear important principles description, good advices: a good book on software engineering
When a 22 years old book on software engineering feels as good, useful and actual as this one, there's no doubt we're talking about a very good book. I really think that the author managed to clearly convey and argument important software engineering principles, as well as to share valuable personal opinions and experiences.

Important topics covered include (but are not limited to):
- evolutionary software development and delivery
- requirement specification
- solution evaluation and cost/impact estimation
- (Fagan's) formal inspection
- Practical hints in different areas (how to cope with tight deadlines, fuzzy requirements and so on)

Although formal inspections are most likely going to be overkill for small and medium sized software projects - where TDD and agile development techniques can nowadays suffice andpossibly be even better quality assurance techniques - I personally think that all other principles, methodologies and hints contained herein can be very valuable in many circumstances to all software engineers, architects and developers; novices and veterans alike.

Despite the fact that there are a few redundancies here and there (and that's pretty much the only reason why I don't rate this book 5 stars), I still think that the author managed to keep it very easy and pleasant to read; so, I still like to pick it up again for a refreshment every once in a while and I have no reserves or hesitation whatsoever in recommending it to everyone involved in software development.

A project management epiphany
Don't let the publishing date of this book fool you.This is a timeless reference in the art of requirements management and software inspections.It was an epiphany for me as a young software project manager in the late 80's, and it is still on my bookshelf today. It was written by a project manager who has "walked the walk".As another reviewer alluded, this book positively reeks with credibility and real-world experience.And the scope of its requirements management methodology is much wider than just software development -- it can be applied to virtually any project management discipline.Most failed projects were doomed from the start by their faulty requirements management or complete lack thereof.If every budding project manager read this book and practiced this methodology, the world would be a better place.Strong words, but read the book and see if it isn't true.You might also visit the www.gilb.com website -- lots of good stuff there, and a lot of it is free.

Excellent Book On Software Engineering
This book covers two very important software engineering topics: the unambiguous specification of business goals and product specification and on evolutionary project management. It also covers the Fagan inspections process which is one of the most powerful techniques in software development. If you like this book, you should also consider the book "Competitive Engineering" by the same author.

Sound ideas, but tedious to read
I found this book hard to read. I often had to force myself to read further, although the ideas and principles described are important and should be required knowledge of any software engineer and SE manager (whichdoes not mean that they necessarily apply to all projects).

The bookcontains endless redundancy and lots of hard to understand details ofprojects the author has worked on. One chapter even contains excerpts fromother books and articles that confirm the author's views - as though theauthor feared he hadn't been convincing enough (that wasn't theproblem).

In summary, the book should have had half the length and thatwould have still covered the same content. It might be interesting toreaders new to the principles of evolutionary delivery, measurable attribteobjectives, and inspection.

Simply the best book on software development I haveread
Firstly, don't let the title put you off -this book is relevant to a lot of people who wouldn't call themselves "sofware engineers" or "managers" - it's also highly relevant to systems analysts /designers & just about any sort of IT consultant, amongstothers.

What separates this from most other books on software developmentis that just about every page is obviously written by someone who has beenthere and done it (recently), not just talked about it. The main ideas ofthe book (evolutionary delivery, defining ojectives as either"functional" or "attributes") may not seemrevolutionary, but apply it and it could revolutionise your project andmaybe career. No IT book I've ever has ever affected my own work soprofoundly.

It's also well written and exceptionally well laid out. Moreplease, Tom! ... Read more

Product Description

• Presenting the most comprehensive and practical introduction to the principles of software engineering and how to apply them, this updated edition follows an object-oriented perspective
• Includes new and expanded material on agile and emerging methods, metrics, quality assurance security, real-world case studies, refactoring, test-driving development, and testing
• Case studies help readers learn the importance of quality factors, appropriate design, and project management techniques

Customer Reviews (1)

Fast answering
I had a problem when I got this through delivery company ,cause of my apt Structural Systems. Anyway. When I tracked where my book is. A person answered for my e-mail immediately.
Nice price and nice service.
But one more thing, if that is possible like reminding me through e-mail when the book get here.
It will be better :)

Thank u
... Read more

Product Description
Introduces students, teachers, researchers, and practitioners to experimentation and experimental evaluation with a focus on software engineering in order to provide guidelines for performing experiments evaluating methods, and techniques in software engineering. DLC: Software engineering. ... Read more

Customer Reviews (1)

Way overpriced.
The book in and of itself isn't terrible, in fact I even referenced it a few times after the class. There's just NOTHING in there to even begin to justify the price; even for a text book this is crazy expensive. ... Read more

Product Description
Software Engineering Economics is an invaluable guide to determining software costs, applying the fundamental concepts of microeconomics to software engineering, and utilizing economic analysis in software engineering decision making. ... Read more

Customer Reviews (6)

Still a classic
Software Engineering Economics is one of the biggest classics in software engineering books. Still today (2004) much of the content is valid and the discussions are very useful. When reading this book you should realize that it's from 1981 and that much has changed since then.

Personally I especially likes the Part III and Part IV which were about the factors changing the software estimate and the reasons why. The last chapter of the book is something everyone should read who is working in quality/process management and is trying to improve productivity of a large project.

Still a classic and worth reading!

A classic "must read" - but be aware of its limitations
"Software Engineering Economics" is *the* book to be considered for anybody wishing to seriously enter the world of software cost estimation - only if it were because of the extremely great influence this book has had on this very peculiar aspect of software engineering. In this aspect, Barry Boehm is undoubtly the master.

HOWEVER, it must be kept in mind that the book itself is somewhat outdated - COCOMO 81, as defined by Barry Boehm, has been overtaken by new technologies and in particular by the surge in PCs & the Internet. The basic model is still valid - I still use it myself - provided you are aware what the background in computing was when it was written, and you carefully assign the adjustment factors.

Barry Boehm himself recognizes that COCOMO 81 is no longer valid - hence his collaboration with COCOMO II, which has addressed many of the problems that affected the old COCOMO 81 (e.g., it was mainly thought for development of software on expensive mainframes, and development tools have greatly evolved since that time). Still, I insist, if you are careful when making your estimations, the model and the techniques presented in this book are very useful and could be applied even on more modern projects.

My second HOWEVER is related to use the model presented in this book for Software Maintenance purposes. Though the book has a chapter on this issue, by opinion is a radical NO-No on this particular issue. COCOMO 81 (as presented in this book) and COCOMO II are adequate for software development purposes. I totally disagree that they are adequate for software Maintenance purposes (though COCOMO II is at least not so very bad). Apart from the fact that it ignores things such as regression testing, or the number of releases to be made during such maintenance, it also ignores the fact that software "degrades" during such maintenance - subsequent modifications introduce more and more stress on the original design, until at a certain moment the software requires a great "overhaul" in order to solve a lot of patchwork that has accumulated over the years. Hence the typical case of having to redesign a complete new software system because maintenance of the old system becomes too expensive.

In any case, if aware of such limitations, I can highly recommend it.

Economic analysis of software decisions making
A classic reference on estimating the cost of software projects, economic analysis techniques, and applying economic principals to upper-level management of software projects. The intimidating appearance of the text on initial inspection is overcome by the author's excellent organization of the content into small chapters and his lucid writing style. The definition of a software cost model called the constructive cost model (COCOMO) is a major centerpiece. Another centerpiece is the chapters on cost-effectiveness analysis, multiple goal decision analysis, dealing with uncertainties and the value of information, software project planning and control, and improving software productivity. Alternatives to cost models such as experts, analogy, Parkinson, price-to-win, top-down, and bottom-up are discussed in Chapter 22. Uses several case studies for example a transaction processing system. Contains an excellent set of questions and exercises at the end of each chapter.

The COCOMO model is calibrated by industry data and expert opinion. Given module size estimates in lines of code as input the COCOMO model will predict effort and schedule in man-months.The COCOMO predictions cover the plans, product design, programming, and integration & test portions of the life cycle. The validity of the model is illustrated by charting actual vs. COCOMO prediction and the detailed analysis of the COCOMO cost driver attributes in Chapters 24-26. Product attributes are required software reliability (RELY), data base size (DATA), and product complexity (CPLX). Computer attributes are execution time constraint (TIME), main storage constraint (STOR), virtual machine volatility (VIRT), and computer turnaround time (TURN). Personnel attributes are analyst capability (ACAP), applications experience (AEXP), programmer capability (PCAP), virtual machine experience (VEXP), and programming language experience (LEXP). Project attributes are modern programming practices (MODP), use of software tools (TOOL), and required development schedule (SCED).

Readers should be aware that some aspects of the COCOMO have been replaced by the publication of the "Software Cost Estimation with COCOMO II" book. The "COCOMO II" book contains a preface section titled"Relation to 1981 Software Engineering Book". I recommend keeping a copy of this preface handy while you read "Software Engineering Economics" because it provides a chapter-by-chapter assessment of the relevance of the "Software Engineering Economics" content in the year 2000.

Classic Required Reading
For those engaged in Software Project Management this book is an excellent reference. Free software available from University of Southern California references this book.

Outdated classic
I own a copy and have referenced it numerous times.Perhaps I'm too veteran, but I don't look too often anymore.You may still find this book useful, and it certainly is cited very often, but be warned - it waswritten in 1981.How much has the software industry changed since then? ... Read more

Product Description
This book is certainly about software development management, but it is also a book about business. Managers can no longer afford to discuss these two topics independently. This book is meant to eliminate the seat-of-the-pants intuition and rough approximations that have been far too prevalent in software development management. The growing popularity of agile methods has shown that a healthy balance between strict process and individual flexibility can be achieved. David Anderson takes it a step farther, and explains how the healthy balance of agility can help businesses become more profitable. The result is a book that will allow managers to foster teams that produce better software, less expensively, on time, and with fewer defects. ... Read more

Customer Reviews (14)

Agile Management for Software Engineering
I don't mind buying books from Amazon, but the only thing about Amazon is they charge you shipping charges, why can't they just ship all the books at one time instead if they are in stock! I know it is only a estimate but we put the estimate on the purchase orders, and when we receive each item, there is a charge for each shipment!When we have to reconcile the orders, the amount is different then what is on the purchase order.So we have to do an amendment to either increase or decrease the order!
Also if the books are instock at the time I order, why do they send messages saying "Your order is delayed and will be shipped at a later date, what is up with that if they are in stock! Ordering from Amazon is a pain!

Very Good Text for the Subject
This text book treats the subject of agile software management well. The examples and explanations are quite comprehensive.

Simple and easy to apply
My professor required this book for my software project planning course.Being from a science background, I've never been very interested in business-related subject matter.However, in this book, Anderson provides simple models and strategies that seem simple and easy to apply.I've even had a somewhat hostile view of management in the past.This book has made me re-evaluate my attitude.I can now see that management does have an important role in a healthy organization.

IF...
Abraham Lincoln once asked something like, "If you call a tail a leg, how many legs does a dog have?" The answer is four. "Just because you call a tail a leg doesn't make it so." Just because you want to call some development practice "Agile" doesn't make it so. In this book, David Anderson makes a case for calling Theory of Constraints the underlying definition of Agile software development practices. The principle tie is that a key measure in the Theory of Constraints is called Throughput; the amount of value delivered to the customer. Agile methods pride themselves as delivering value to the customer quickly. Based on the Theory of Constraints definition, the Feature Driven Development (FDD) method, Anderson's personal expertise, turns out to be the most Agile of all.
In making the case for the Theory of Constraints based approach, Anderson has given us a lot of formulas and metrics for looking at software projects. This is the most thorough treatment of the subject I have seen yet. I wasn't fully satisfied with the metrics as I felt the book didn't deal with the biggest problem in metrics, the problem of characterizing the measure. To do good metrics, you have to be very clear on what you are measuring, the characterization problem. Without that, all the formulas, graphs, and trends are pretty much useless. Most of the book dealt with the problem by saying, "If you could measure `X', then..." I got really tired of all the Ifs in the book.
In fact, I am not sure I should like this book or not. I found myself half of the time saying to myself, "Hmm, that is a interesting idea," and the other half saying, "I don't think so." Perhaps it was all the Ifs, perhaps it was the repetition. I am glad to say at the end of the book Anderson does appear to have the intelligence to note that one size does not fit all and does a nice job of suggesting where the best choices in software development approaches might be.
So, who should read this book? Well, if you like Donald Reinertsen's and Eliyahu Goldratt's work and live in the software world, this book is for you. If you have to teach Agile seminars to software professionals (like me), then this should be on your reading list as well. If you are general software project manager or developer who is looking to improve the way you do software development, then I would probably pass on this book. Not that the ideas are all wrong but you probably will get lost along the way. If...

Metrics for agile software development
The text gives a good explantion of agile practices and theory. It looks closely at three agile development methods : Scrum, Extreme Programming (XP), and Feature Driven Development (FDD), with an emphasis on FDD.

One of Anderson's key points is although agile software development is an empirical process (eg. dependent upon experimentation and observation), it is not necessarily chaotic.Therefore, it can be planned and predicted.

The text also emphasizes in order for agile software development to be adopted in a large corporation, software managers need to provide development metrics that focus on what matters to the CIO -- namely financial and production metrics.

The bulk of the text covers how to derive these production and financial metrics for the various agile software development methods.Anderson's proposed metrics are based on throughput accounting and Goldratt's Theory of Constraints.Specifically, he covers how to compute net profit, throughput, and production rates.

Thought provoking and highly recommended. ... Read more

Product Description

Software practitioners are rapidly discovering the immense value of Domain-Specific Languages (DSLs) in solving problems within clearly definable problem domains. Developers are applying DSLs to improve productivity and quality in a wide range of areas, such as finance, combat simulation, macro scripting, image generation, and more. But until now, there have been few practical resources that explain how DSLs work and how to construct them for optimal use.

Software Language Engineering fills that need. Written by expert DSL consultant Anneke Kleppe, this is the first comprehensive guide to successful DSL design. Kleppe systematically introduces and explains every ingredient of an effective

language specification, including its description of concepts, how those concepts are denoted, and what those concepts mean in relation to the problem domain. Kleppe carefully illuminates good design strategy, showing how to maximize the flexibility of the languages you create. She also demonstrates powerful techniques for creating new DSLs that cooperate well with general-purpose languages and leverage their power.

Completely tool-independent, this book can serve as the primary resource for readers using Microsoft DSL tools, the Eclipse Modeling Framework, openArchitectureWare, or any other DSL toolset. It contains multiple examples, an illustrative running case study, and insights and background information drawn from Kleppe’s leading-edge work as a DSL researcher.

Specific topics covered include

• Discovering the types of problems that DSLs can solve, and when to use them
• Comparing DSLs with general-purpose languages, frameworks, APIs, and other approaches
• Understanding the roles and tools available to language users and engineers
• Creating each component of a DSL specification
• Modeling both concrete and abstract syntax
• Understanding and describing language semantics
• Defining textual and visual languages based on object-oriented metamodeling and graph transformations
• Using metamodels and associated tools to generate grammars
• Integrating object-oriented modeling with graph theory
• Building code generators for new languages
• Supporting multilanguage models and programs

This book provides software engineers with all the guidance they need to create DSLs that solve real problems more rapidly, and with higher-quality code.

Customer Reviews (3)

Disappointing
The title and description promised much, and my shelf of often-used computing books is dominated by Addison-Wesley, so I gave this a shot. Unfortunately, the book seems to be devoid of any real substance. I approached this book as a practitioner trying to build a DSL for production use, and wasn't able to find much beyond a regurgitation of one can get from the blogosphere. If this is your very first foray into DSLs it might be useful, otherwise you'll find Terrence Parr's "Language Implementation Patterns" to be a substantive and rewarding read, unlike this book. Also, Fowler's been threatening to publish his DSL book any day now.

Reinventing the wheel. As a square.
The author's reinvent terms that are already known for decades in computer science. Instead of building on top of existing knowledge she tries to create her own concepts but fails. If you are looking for information on Domain-Specific Languages or in programming languages in general stay away from this book.

The first in-depth guide to DSL design, covering language specification, concepts, DSL components and modeling, and much more
SOFTWARE LANGUAGE ENGINEERING: CREATING DOMAIN-SPECIFIC LANGUAGES USING METAMODELS is written by a DSL consultant and is the first in-depth guide to DSL design, covering language specification, concepts, DSL components and modeling, and much more. A fine survey of DSL frameworks, APIs, and different approaches, this will reach any college-level, advanced library catering to IT programmers.
... 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

Proven Software & Systems Requirements Engineering Techniques

"Requirements engineering is a discipline used primarily for large and complex applications. It is more formal than normal methods of gathering requirements, and this formality is needed for many large applications. The authors are experienced requirements engineers, and this book is a good compendium of sound advice based on practical experience." --Capers Jones, Chief Scientist Emeritus, Software Productivity Research

Deliver feature-rich products faster, cheaper, and more reliably using state-of-the-art SSRE methods and modeling procedures. Written by global experts, Software & Systems Requirements Engineering: In Practice explains how to effectively manage project objectives and user needs across the entire development lifecycle. Gather functional and quality attribute requirements, work with models, perform system tests, and verify compliance. You will also learn how to mitigate risks, avoid requirements creep, and sidestep the pitfalls associated with large, complex projects.

• Define and prioritize customer expectations using taxonomies
• Elicit and analyze functional and quality attribute requirements
• Develop artifact models, meta-models, and prototypes
• Manage platform and product line development requirements
• Derive and generate test cases from UML activity diagrams
• Deploy validation, verification, and rapid development procedures
• Handle RE for globally distributed software and system development projects 
• Perform hazard analysis, risk assessment, and threat modeling

Customer Reviews (6)

Not a Book Really!
For my post-grad course I was required to read this book as well as Just Enough Requirements Management. The idea was to use this book for practical knowledge but it is so poorly structured and written that its simply impossible to read. It seems like a compilation of multiple academic papers; there is no flow between chapters and many topics are discussed randomly. So much is written but nothing is explained or discussed enough. They might as well have published just the table of content.

This isn't really a book; better suitable for Siemens staff as a training hand-book.

Outdated and shallow
Outdated content, only few figures were passable.Better off using professional blogs.
Very uneven chapters, poor editing with disparate styles making the reading choppy.
Not really a book, rather a compilation of loosely related chapters.

Great Book!
This is the best book on requirements engineering that I have ever read. I is filled with excellent examples from the authors' personal experience and it covers virtually all of the topics that would normally be included in an academic systems and software requirements course. It will be invaluable to both academics and practitioners. Both the authors and their employer are to be congratulated for making available information about real projects that many employers would consider proprietary.

sound advice...
This little book is packed with sound advice.

Pros-
The book covers a wide variety of topics and does so at a detailed enough level that you have a good understanding of the topic. They do not waste time on filler content. It covers building a requirement's taxonomy, eliciting requirements, Model-Driven Requirements Engineering, quality attributes, the importance of architecture, engineering platforms, requirements management, requirements-driven testing, rapid development techniques, hazard and threat analysis, distributed requirements engineering, and creating a requirements database.

As the book covers all these topics the authors made really great use of visualizing the material with really great diagrams.

They cover a lot of best practices and offer really sound advice. The tips on developing uses cases are great.

Each chapter comes with an extensive reference section.

Cons-
The publisher should have made the book a bit larger. The diagrams included in the book are some of the best I have seen, but they are very small. They could have made electronic versions available online (I guess I could blow them up on a copier).

The book was definitely written by people hanging out in the engineering world because they use a ton of acronyms and they are not always easy to figure out. They did not include all of them in the index.

I found it a little annoying that some of the key concepts/tools point to internal Siemens tools like the DesignAdvisor and URML (Unified Requirements Modeling Language).

All in all
I highly recommend this book. Its size allows me to carry it around with my laptop. I have been taking it everywhere for weeks now and every time I think of shelving it at work or at home I choose not to so I can review one or more of the sections one last time.

If you are involved in software development at all (developer, user, project manager, architect, tester, etc.) this is required reading.

A Practioner's Guide to Requirements
Defining and managing requirements is not easy with simple, small systems but requirements definition and management in large, complex systems has to be set up, thought through and carefully managed with the best interest of clients or end users in mind.That is a lot of ground to cover and in many organizations, folks have difficulty figuring out who is responsible for what and when. This book walks through the details of how to approach and manage requirements in many different environments with various development methodologies.I particularly like the explanations and the way roles are laid out for managers, developers and support organizations, as well as stakeholders and end users.
Having worked with requirements as a practioner in commercial and government development shops, I wish I had had this book to help explain some of these key points for different methods and development approaches.Then, it would have been easier to concentrate on requirement's attributes, definition and analysis techniques, and traceability.If you are an agile shop, there is a direct approach on how to capture, group, iteratively develop and then test requirements.There is also an excellent chapter (8 Requirements Driven System Testing) that should be read by every software or system developer and testing group member. This is the book that you should have available for all development teams and make sure they use it! ... Read more

Product Description

This is the Mobipocket version of the print book.

"When it comes to software security, the devil is in the details. This book tackles the details."
--Bruce Schneier, CTO and founder, Counterpane, and author of Beyond Fear and Secrets and Lies

"McGraw's book shows you how to make the 'culture of security' part of your development lifecycle."
--Howard A. Schmidt, Former White House Cyber Security Advisor

"McGraw is leading the charge in software security. His advice is as straightforward as it is actionable. If your business relies on software (and whose doesn't), buy this book and post it up on the lunchroom wall."
--Avi Rubin, Director of the NSF ACCURATE Center; Professor, Johns Hopkins University; and coauthor of Firewalls and Internet Security

Beginning where the best-selling book Building Secure Software left off, Software Security teaches you how to put software security into practice.The software security best practices, or touchpoints, described in this book have their basis in good software engineering and involve explicitly pondering security throughout the software development lifecycle. This means knowing and understanding common risks (including implementation bugsand architectural flaws), designing for security, and subjecting all software artifacts to thorough, objective risk analyses and testing.

Software Security is about putting the touchpoints to work for you. Because you can apply these touchpoints to the software artifacts you already produce as you develop software, you can adopt this book's methods without radically changing the way you work. Inside you'll find detailed explanations of

• Risk management frameworks and processes
• Code review using static analysis tools
• Architectural risk analysis
• Penetration testing
• Security testing
• Abuse case development

In addition to the touchpoints, Software Security covers knowledge management, training and awareness, and enterprise-level software security programs.

Now that the world agrees that software security is central to computer security, it is time to put philosophy into practice. Create your own secure development lifecycle by enhancing your existing software development lifecycle with the touchpoints described in this book. Let this expert author show you how to build more secure software by building security in.

Customer Reviews (19)

High-level security concepts book.
Excellent high-lvel book for anyone involved with software development and implementation. This book digs deep with enough details of security in coding and testing practices and how to avoid security related bugs and vulnerabilities. The book also does well in terms of secure coding, white box and black box testing very well.

Few things where this book falls short "Ignorant" to emerging application landscape and the coding complexities in a multi-platform and application integration environment - J2EE, .NET, XML Web Services and SOA.I am sure, the author will agree on those gaps hopefully we see in the next edition of this book.

The book deserves 5 stars for the concepts + illustrations and 3 stars for those keen on development details for distributed applications.

The best secure development lifecycle book
Software Security is the best book for learning to integrate security throughout your software development lifecycle.It contains all the security material that is missing from software engineering books.The author understands that your software development lifecycle is different from his, and so focuses on seven touchpoints that can be introduced into any software development lifecycle, instead of attempting to sell you a new lifecycle.He also understands that no matter how important security is to you, you can't change everything about you develop software tomorrow, so he introduces the touchpoints in order of effectiveness based on his extensive consulting experience, starting with tool-assisted code reviews and architectural risk analysis.

If you're a software developer, Software Security is an essential book to have on your shelf, and you'll also want a secure programming book like Secure Programming with Static Analysis (Addison-Wesley Software Security Series) or the author's own Building Secure Software: How to Avoid Security Problems the Right Way.

Good book for secure software coding !
A required reading for anyone involved with software development and implementation. This book drills-down to security in coding and testing practices and how to avoid security related bugs and vulnerabilities. The concepts illustrated on secure coding, white box and black box testing are excellent. As a developer/architect, I thoroughly enjoyed this book and I suggest to everyone who wants to get started on secure coding and testing practices.

Couple of things I QUIBBLE with are... the book does'nt realize the emerging issues and how-to's for build/refactor security for distributed application proliferation as your it - Portals, Web Services and SOA. The way we develop software is changing, the applications are becoming more pervasive and no-longer contained standalone to a system which makes the built-in security brittle impeding the agile business requirements for application/process orchestration, b2b federation and Web based application mashups. I am sure, the author will realize those gaps in the next edition of this book.

Havingsaid - This book is still a must-read for the budding security developer who wants to focus on secure programming and testing.

What is MISSING - You will not find answers for how you do secure web-centric applications, XML Web services - message-level security, identity federation and other b2b application complexities.

Required residing for all software developers
The root cause of many security vulnerabilities is poorly written software. Often, software applications are written without security in mind. The logical, yet elusive, solution is to ensure that software developers are trained in writing secure code.

Software Security: Building Security In is a valiant attempt to show software developers how to do just that. The book is the latest step in Gary McGraw's software security series, whose previous titles include Building Secure Software and Exploiting Software.

In past decades, writing secure code was left to the military and banking industry. Today, with everything on networks, all sectors must get into the act.

Much of the problem is that organizations target their security elsewhere--specifically on networks--rather than on software. But so many malicious attacks are directed at software that it is foolish to leave this vulnerability exposed.

McGraw goes into detail not only about writing secure code but also about key related areas, which he terms "the seven touchpoints of software security."

These points comprise code review, architectural risk analysis, penetration testing, risk-based security tests, abuse cases, security requirements, and security operations. A major portion of the book effectively discusses these "touchpoints," making the work a recommended tool for inculcating software developers with a security mind-set.

A powerful book with deep truths for secure development
I read six books on software security recently, namely "Writing Secure Code, 2nd Ed" by Michael Howard and David LeBlanc; "19 Deadly Sins of Software Security" by Michael Howard, David LeBlanc, and John Viega; "Software Security" by Gary McGraw; "The Security Development Lifecycle" by Michael Howard and Steve Lipner; "High-Assurance Design" by Cliff Berg; and "Security Patterns" by Markus Schumacher, et al.Each book takes a different approach to the software security problem, although the first two focus on coding bugs and flaws; the second two examine development processes; and the last two discuss practices or patterns for improved design and implementation.My favorite of the six is Gary McGraw's, thanks to his clear thinking and logical analysis.The other five are still noteworthy books.All six will contribute to the production of more security software.

Gary McGraw's book gets my vote as the best of the six because it made the biggest impact on the way I look at the software security problem.First, Gary emphasizes the differences between bugs (coding errors) and flaws (deeper architectural problems).He shows that automated code inspection tools can be applied more or less successfully to the first problem set, but human investigation is required to address the second.Gary applauds the diversity of backgrounds found in today's security professionals, but wonders what will happen when this rag-tag bunch (myself included) is eventually replaced by "formally" trained college security graduates.

Second, Gary explains that although tools cannot replace a flaw-finding human, they can assist programmers trying to avoid writing bugs.Gary is the only author I encountered who acknowledged that it is unrealistic to expect a programmer to keep dozens or hundreds of sound coding practices and historical vulnerabilities in his head while writing software.An automated tool is a powerful way to apply secure coding lessons in a repeatable and measurable manner.Gary also reframed the way I look at software penetration testing, by showing in ch 6 that they are best used to discover environmental and configuration problems of software in production.

Third, Gary is not afraid to point out the problems with other interpretations of the software security problem.I almost fell out of my chair when I read his critique on pp 140-7 and p 213 of Microsoft's improper use of terms like "threat" in their so-called "threat model."Gary is absolutely right to say Microsoft is performing "risk analysis," not "threat analysis."(I laughed when I read him describe Microsoft's "Threat Modeling" as "[t]he unfortunately titled book" on p 310.)I examine this issue deeper in my reviews of Microsoft's books.Gary is also correct when he states on p 153 that "security is more like insurance than it is some kind of investment."I bookmarked the section (pp 292, 296-7) where Gary explained how the "19 Deadly Sins of Software Security" mix "specific types of errors and vulnerability classes and talk about them all at the same level of abstraction."He's also right that the OWASP Top Ten suffers the same problem. Finally, Gary understands the relationships between operators and developers and the importance of security vocabulary.

I was pleasantly surprised by "Software Security".I reviewed an early draft for Addison-Wesley and wondered where the author was taking this book.It ended up being my favorite software security book, easily complementing Gary's earlier book "Building Secure Software."In my opinion, Gary is thinking properly about all the fundamental issues that matter.This book should be distributed to all Microsoft developers to help them frame the software security problem properly. ... Read more

Product Description

Most modern software development projects require teams, and good teamwork largely determines a project’s success. The Team Software Process (TSP), created by Watts S. Humphrey, is a set of engineering practices and team concepts that produce effective teams, thereby helping developers deliver high-quality products on time and within budget. TSP bridges Humphrey’s seminal work on the Capability Maturity Model (CMM), an improvement framework for the entire software organization, and his Personal Software Process (PSP), practices designed to improve the work of individual developers.

Typical first-time TSP teams increase productivity by more than 50 percent while greatly increasing the quality of their delivered products. However, TSP teams only continue to improve under the guidance of a capable coach. One industrial-strength team, for example, increased its productivity by an additional 94 percent and reduced test defects by 85 percent through three consecutive TSP quarterly product release cycles. Without competent coaching, teams often do not progress much beyond the initial one-time improvement seen after the introduction of the TSP.

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