Browse Books

Reviewer: Mark Edward Staknis

The current popularity of object-oriented programming is overshadowing traditional software engineering practices and concerns. As a consequence, new programmers may falsely believe that established approaches to software engineering are no longer valid. Ince shows that conventional software engineering and object-oriented programming are complementary rather than competitive. His book presents well-established lessons of software engineering in a contemporary, object-oriented context. The book focuses on the front end of the software life cycle, that is, on requirements definition, prototyping, and design. Validation and testing are also emphasized. The treatments of prototyping and validation are especially good. The author chose C++ as the presentation language because it is so widely used in the software industry. Although the author claims that familiarity with C or C++ is unnecessary, readers who already know the languages will benefit more from the material. The book has a top-down organization. Chapters 1 through 3 provide a conceptual overview, chapters 4 through 12 cover details, and chapters 13 and 14 present a brief summary and case study. Chapter 1 introduces the software engineering life cycle, stresses the importance of verification and validation, and discusses the difficulties of software reusability and maintenance. Chapter 2 is a six-page introduction to object-oriented programming concepts, which include abstract data types, polymorphism, single and multiple inheritance, and dynamic binding of functions to objects. Chapter 3 gives an overview of requirements definition and functional specification. Jackson Structured Design (JSD) is used for requirements definition, and dataflow dia grams (DFDs) are used for functional specification. Both are natural choices for object-oriented design. Chapters 4 through 12, which cover details, provide the book's bulk and substance. Chapter 4 presents JSD and requirements definition. Entity/action analysis is described, and structure diagrams are developed for a number of examples. Chapter 5 discusses requirements in terms of validation. Guidelines for conducting reviews are covered generally, then presented specifically for entity analysis. Prototyping is considered in terms of both requirements definition and requirements validation, and different approaches to proto typing are described. Chapter 6 develops the notion of an abstract data type (ADT) and explores ADTs axiomatically through preconditions and postconditions. The axiomatic treatment is intuitive rather than formal. Chapters 7, 8, and 9 discuss C++. Chapter 7 presents features of C used in C++, including data types, operators, and control flow. Chapter 8 focuses on object-oriented features of C++. It describes the use of classes to implement ADTs, and explores information hiding and inheritance. Chapter 9 presents examples and considers approaches to testing. Chapters 10, 11, and 12 again turn to software engineering. Chapter 10 focuses on functional specification through DFDs. A number of illustrative examples are included, and DFDs are considered as bases from which to develop system tests. Chapter 11 describes pseudocode generation through functional decomposition of DFDs. Chapter 12 discusses prototyping as it applies to object-oriented programming. The book's organization is impressive because it ties a variety of topics together coherently. The book covers a lot of ground in a little over 200 pages, so no topic is covered in depth. Readers who want more detail must consult other sources, some of which are referenced in short bibliographies at the ends of chapters. For example, the book presents only the minimal features of C++ needed for examples; readers who wish to use C++ must look elsewhere. The presentation warrants minor criticism. The wide, narrowly-spaced lines of text tire the eyes. Many sections contain long passages of prose that could have been broken up with tables or figures. The British English, such as car “hiring” rather than “rental” and hotel room “booking” rather than “reservation,” may distract some US readers. The copyediting missed unnecessary commas and occasional grammatical errors. The book will be most useful to computer professionals interested in object-oriented programming who have no software engineering education. Its brevity and lack of exercises recommend against its use as a primary textbook, but it could serve as a supplementary text in undergraduate courses in software engineering or object-oriented design. Overall, this timely book plays a crucial role in bringing traditional software engineering up to date.