The Virtual Bookcase Reviews of 'Software Engineering':
Reviewer Rob Slade wrote:
Part one is an overview. Chapter one is an introduction, a FAQ
(Frequently Asked Questions list), definitions, and, interestingly, a
section on ethics. A broad review of system development concepts
(such as emergent properties) is presented as computer based software
engineering, in chapter two. Stages in the software development
process, none detailed, are listed in chapter three. Project
management is discussed in chapter four.
Part two looks at software requirements. Chapter five examines
different types of requirements. Requirements engineering is software
engineering in miniature, as chapter six points out. There is a heavy
emphasis on the Universal Modeling Language (UML) in chapter seven's
explanation of system models. The benefits and dangers of software
prototyping are examined in chapter eight. Chapter nine points out
that formal specification does require special training on the part of
users, but can identify problems in requirements specifications.
(More extensive examples would be helpful in making this point more
convincing.)
Part three reviews design, and the chapters are mostly divided by
system type. Chapter ten explains architectural design, and reviews
tools and models. (Security, and other concerns, are addressed
throughout the book: an example in this chapter points out that
interrupt driven architectures are complex and difficult to validate.)
Distributed systems architecture itself gets oddly short shrift in
chapter eleven, which concentrates on client/server and CORBA (Common
Object Request Broker Architecture). Object-oriented design is shown
to be very much like modular design in chapter twelve. (The stated
objective of the text is to introduce UML, but the explanations are
not very clear.) Chapter thirteen looks at real-time software design
but does not seem to be as complete as other topics. Design with code
reuse is a good overview, but chapter fourteen starts out with the
statement that electrical and mechanical engineers rely on component
reuse, ignoring the lack of a broad range of standard components in
the software environment. There are good, basic suggestions for user
interface design, in chapter fifteen, although the discussion is
limited. For example, the recommended principles suggest confirmation
of destructive actions, but don't note the fact that even such
confirmations become automatic over time, and therefore are not
particularly useful.
Part four deals with critical systems. Chapter sixteen looks at
dependability in terms of availability, reliability, safety, and
security. Critical systems specification, in chapter seventeen,
examines dependability (and failure) metrics. Risk analysis is
discussed, but not in the usual combination of probability and
severity. Critical systems development is examined both in terms of
fault avoidance and fault tolerance in chapter eighteen.
Part five covers verification and validation. Chapter nineteen
concentrates on code inspection and the Cleanroom process. Software
testing, in chapter twenty, looks at types, cases, and procedures.
Critical systems validation, in chapter twenty one, is basically the
same process as the previous chapter, but more important.
Part six, on management, is mostly a precis or list of principles from
other sections. Chapter twenty two deals with managing people,
looking at limits, motivation, group dynamics, recruiting, and
keeping, as well as a quick overview of the People Capability Maturity
Model (P-CMM). It's not a large section, but it is nice to see the
importance of personnel recognized in this way. Software cost
estimating, in chapter twenty three, is interesting, but possibly not
terribly useful. Quality management is dealt with in chapter twenty
four. Chapter twenty five reviews process improvement and the
Capability Maturity Model (CMM), mentioning the work of Walter Deming
but not, intriguingly, dealing with the fact that Deming's later work
suggested that business had gone overboard in the pursuit of quality.
Part seven deals with evolution and change. Chapter twenty six
discusses legacy systems with a description of mainframe program
structures and guidelines for the assessment of the possibilities for
updating the system. Software change is reviewed in chapter twenty
seven, with maintenance and re-architecting leading to a description
of re-engineering in chapter twenty eight. Chapter twenty nine
finishes off with configuration management, emphasizing version
documentation more than change control.
The book is written as a textbook, with a summary of key points and a
very decent set of exercises at the end of every chapter. It
certainly stands above the other systems development texts that I have
experienced. However, this work also has value beyond the classroom.
A great many professionals, such as information security officers,
need to know the operations, procedures and concepts of software
engineering without necessarily being programmers themselves. For
these people, this volume makes a clear and excellent reference.
copyright Robert M. Slade, 2002
Add my review for Software Engineering
Book description:
Software systems are now ubiquitous. Virtually all electrical equipment now includes some kind of software; software is used to help run manufacturing industry, schools and universities, health care, finance and government; many people now use software of different kinds for entertainment and education. The specification, development, management and evolution of these software systems make up the discipline of software engineering. Even simple software systems have a high inherent complexity so engineering principles have to be used in their development. Software engineering is therefore an engineering discipline where software engineers use methods and theory from computer science and apply this cost-effectively to solve difficult problems. These difficult problems have meant that many software development projects have not been successful. However, most modern software provides good service to its users; we should not let high-profile failures obscure the real successes of software engineers over the past 30 years. Books inevitably reflect the opinions and prejudices of their authors. Some readers will inevitably disagree with my opinions and with the choice of material which I include. Such disagreement is a healthy reflection of the diversity of the discipline and is essential for its evolution. Nevertheless, I hope that all software engineers and software engineering students can find something of interest here. Although the book is intended as a general introduction to software engineering, it is biased, to some extent, towards my own interests in system requirements engineering and critical systems. I think these are particularly important for software engineering in the 21st century where the challenge we face is to ensure that our software meets the real needs of its users without causing damage to them or to the environment. I dislike zealots of any kind, whether they are academics preaching the benefits of formal methods or salesmen trying to convince me that some tool or method is the answer to software development problems. There are no simple solutions to the problems of software engineering and we need a wide spectrum of tools and techniques to solve software engineering problems. I therefore don't describe commercial design methods or CASE systems but paint a broad picture of software engineering methods and tools. Software engineering research has made tremendous strides over the past 15 years but there has been a relatively slow diffusion of this research into industrial practice. The principal challenge which we now face is not the development of new techniques and methods but the transfer of advanced software engineering research into everyday use. I see this book as a contributor to this process. I therefore discuss some techniques, such as viewpoints for requirements engineering, which are reasonably well developed but which are not yet widely used in industry. Finally, it is impossible to over-emphasize the importance of people in the software engineering process. People specify, design and implement systems which help other people with their work. Most of the difficulties of very large system engineering are not technical problems but are the problems of managing large numbers of people with diverse priorities, abilities and interests. Software engineering techniques and tools are only effective when applied in a context which respects these different skills and abilities. Changes from the fourth edition Like many software systems, this book has grown and changed since its first edition was published in 1982. This latest edition started as a relatively minor update of the fourth edition but, in the course of writing the book, I decided that more significant revision and re-engineering was necessary. Although much of the material in the fourth edition has been retained, the following changes have been made: There are five completely new chapters covering computer-based system engineering, requirements analysis, architectural design, process improvement and software re-engineering. The book has been restructured into eight parts covering an introduction to software engineering, requirements and specification, design, dependable systems development, verification and validation, CASE, management, and software evolution. There have been radical revisions of the material on requirements engineering, object-oriented and functional design, and CASE. Project management is introduced in the first part of the book then covered in more detail in a separate section which incorporates previous material on human factors. There is more emphasis on quality management.
In previous editions, I have presented program examples in Ada as I consider this an excellent language for large-scale software engineering. However, Ada has not become as widely used as was once predicted. C or C++ are the programming languages of choice for most personal computer and workstation applications. Because of this wide use, I have included C++ as well as Ada versions of most of the program examples in the book. For safety-critical systems, however, I think it unwise to use a language which includes potentially unsafe constructs. Those examples are, therefore, only presented in Ada. I considered for a long time whether it would be appropriate to include a new chapter on professional and ethical issues. I decided not to do so because the topic is so subjective that it is difficult to present in a balanced way in a single chapter. There are no absolutes in this area and it is best addressed in an interactive context rather than as a chapter of a book. However, I have included a brief discussion of these issues in the introduction to the book. I have also included possible ethical and professional topics for discussion as exercises in many chapters. Links to WWW pages on this topic are included in the Web page whose URL is given below. The further reading associated with each chapter has been updated from previous editions. However, in many cases, articles written in the 1980s are still the best introduction to some topics. As new articles which are useful become available, I will include them on the Web page. The author index in previous editions has been removed. Rather, each entry in the References section includes the page numbers where it has been referenced. Readership The book is aimed at students in undergraduate and graduate courses and at software engineers in commerce and industry. It may be used in general software engineering courses or in courses such as advanced programming, software specification, software design or management. Practitioners may find the book useful as general reading and as a means of updating their knowledge on particular topics such as requirements engineering, architectural design, dependable systems development and process improvement. Wherever practicable, the examples in the text have been given a practical bias to reflect the type of applications which software engineers must develop. I assume that readers have a basic familiarity with programming and modern computer systems. Some examples rely on knowledge of basic data structures such as stacks, lists and queues. The chapters on formal specification assume knowledge of very elementary set theory. No other mathematical background is required. Using the book as a course text There are three main types of software engineering courses where this book can be used: General introductory courses in software engineering. For students who have no previous software engineering experience, you can start with the introductory section then pick and choose the introductory chapters from the different sections of the book. This will give students a general overview of the subject with the opportunity of more detailed study for those students who are interested. Introductory or intermediate courses on specific topics in software engineering such as software specification, design or dependable systems development. Each of the parts in the book can serve as a text in its own right for an introductory or intermediate course on that topic. More advanced courses in specific software engineering topics. In this case, the chapters in the book form a foundation for the course which must be supplemented with further reading which explores the topic in more detail. All chapters include my suggestions for further reading.
The benefit of a general text like this is that it can be used in several different related courses. At Lancaster, we use the text in an introductory software engineering course, in courses on specification, design and critical systems and in a software management course where it is supplemented with further reading. With a single text, students are presented with a consistent view of the subject. They also like the extensive coverage because they don't have to buy several different books. This book covers all suggested material in Units SE2 to SE5 in the ACM/IEEE 1991 Curriculum.
The new edition of this best-selling book provides a comprehensive discussion of software engineering techniques and shows how they can be applied in practical software projects. This book features new coverage of the software process and software process technology, system integration, requirements management, and risk analysis, as well as new chapters on pattern-based reuse, distributed system engineering, and legacy systems. Sommerville has incorporated a more object-oriented approach in this edition—using UML and Java—and has removed much of the material on CASE, formal methods, and Ada, making the book more in tune with current technology and practice. A new discussion of professional ethics in the introduction helps to make readers aware of the responsibilities that come with engineering software. The sixth edition uses Java for all programming examples, and bases all design examples on UML notation. It includes new chapters on pattern-based reuse, distributed system engineering, and legacy systems, as well as new coverage of the software process and software process technology, system integration, requirements management, and risk analysis. This book is designed for readers needing a general introduction to software engineering (development, management, and evolution), especially with regard to system requirements engineering and critical systems.
