I taught introductory software engineering 20 years ago, using a slim volume that provided an accessible overview of the entire field. Sommerville’s text [1], then in its second or third edition, has become, in its latest edition, a massive assemblage of over 700 pages. The rest of the current crop of software engineering texts is much the same. These books are too long and contain far too much material for an introductory course in software engineering. Instructors must pick and choose chapters in order to shoehorn the material into a course, but this is hard to do because discussions of essential topics are too long and too deep.

Jalote’s intention in this book is to present just enough material to teach beginning software engineers what they need to know to do a development project that carries a small product from conception through delivery. The result is a short book that reminds me very much of software engineering textbooks from 20 years ago: topics are dealt with at an introductory level and only the essentials appear, making this sort of book very attractive as a text for introductory software engineering. The approach is good, but how well is it carried out?

On the whole, topics are well chosen and their discussion is good. The first chapter is an introduction to the problem addressed by software engineering and why it is important. The second chapter is an essay about software processes and life-cycle models. The third chapter is a traditional treatment of requirements analysis and specification, the fourth chapter is an overview of project planning and control, and the fifth chapter is an introduction to software architecture. These chapters are all quite good, especially the second, although the requirements chapter emphasizes structured analysis more than one would expect.

The sixth chapter, on software design, is quite poor. Only three software design principles are discussed: coupling, cohesion, and Meyer’s open-closed principle; information hiding is only mentioned briefly in the following chapter on coding. There is an extensive discussion on the obsolete techniques of structured design, followed by a poor discussion on object-oriented design that betrays procedural thinking. The unified modeling language (UML) diagrams presented do not conform to the current version of the notation. The discussion of detailed design is also quite weak. However, chapter 7, on coding, and chapter 8, on testing, are again quite good.

The weakness of the design chapter reflects an overemphasis throughout the book on function-oriented design and programming, and an apparent lack of sophistication in object-oriented design and programming. This is the biggest failing of the book. Its strongest chapters are those on processes and management, an area in which the author is an expert.

What does Jalote leave out that allows him to cover software engineering in far less than half the pages of a book such as Sommerville’s? Surprisingly little. Jalote discusses all the core topics of the field, some recent hot topics such as agile methods, and even somewhat arcane topics such as metrics. He does leave out many topics usually covered in software engineering texts, such as security and safety, user interface design, design patterns, distributed systems, real-time systems, component-based development, service-oriented computing, and software evolution, but these are all--except perhaps for security--somewhat advanced or specialized topics that can rarely be done justice in an introductory course. The real key to the brevity of Jalote’s presentation is that he covers the main points of his topics without going into great detail, which is perfectly appropriate for an introductory text. Unfortunately, he also has relatively few examples and exercises, which damages the pedagogical value of the book.

Despite its shortcomings, this compendium demonstrates a welcome alternative to the reigning philosophy of exhaustive topic coverage in introductory software engineering textbooks. I hope this approach catches on and more texts such as this one will soon appear.