Software Engineering Design: Theory and Practice

Image of Software Engineering Design: Theory and Practice (Applied Software Engineering Series)
Release Date: 
June 14, 2012
CRC Press
Reviewed by: 

“Perhaps the only problem with writing a textbook on design is that there is such a wealth of material that no one textbook could hope to cover it all.”

Software Engineering Design is intended for use as a textbook for an advanced course in software design. Each chapter ends with review questions and references. The student is expected to have previously taken the following courses: introduction to programming, data structures and algorithms, and introduction to software engineering.

A small but significant portion of this book provides an overview of the software development process, something that would not be out of line in a course on software engineering including such topics as software process, software management, balancing conflicting values of stakeholders, testing, quality, and ethics.

The author has principally focused on software design though, extracting the design phase from the surrounding software development lifecycle. Design can itself be viewed as a process having three phases, an initial phase of understanding the problem, an operational phase where the designer is thinking of solutions, and a final phase where the designer chooses and implements the solution. These phases have even finer gradations that are identified and examined:

1. Interpret the problem
2. Evaluate constraints
3. Collaborate/brainstorm
4. Synthesize possibilities
5. Evaluate solutions
6. Implement solutions

Good design implementation principles are addressed as well:

1. Modularization
2. Abstraction
3. Encapsulation
4. Coupling and cohesion
5. Separation of interface and implementation
6. Sufficiency and completeness

Software design strategies are addressed, including structured, functional, and object oriented design. There’s also a chapter on UML (Unified Modeling Language). UML is a set of design paradigms (and tools) used for design modeling, and examples are provided throughout. UML models include use-case diagrams, interaction diagrams, dataflow diagrams, component sequence, behavior sequences, and class diagrams. The author also provides coded examples of UML diagrams in C++ and Java. There’s also a section on view modeling including: user views, process views, physical views, and logical views.

The section on concurrency covers the basics competently and includes a few coding examples in C++. There may not be enough examples however, in the use of concurrency primitives: mutexes and semaphores, something that would be covered in an operating systems course. Without in-depth practice and experience programmers do not deal with concurrency well, and tend to go to extremes by avoiding concurrency entirely or its opposite - creating over-complex designs difficult to debug.

The chapter on patterns for systems and architectural design dovetails nicely with the examples provided in UML. Software patterns covered include distributed, interactive, dataflow, data-centered, and hierarchical systems. The chapter on detailed design patterns includes the original set of “Gang of Four” patterns including the Adapter, Factory, Prototype, Façade, Iterator, and the Observer pattern.

Apart from software patterns there is material on functional and object-oriented design (which an emphasis on object-oriented design), state design, and design for software reuse. Again examples are provided in C++. In the detailed design section the author presents the lowest level of design including programming design language (PDL). There is also material on documentation and naming conventions along with including example file headers.

The last section is a very light treatment of software management including software project roles and responsibilities, Maslow’s psychology of motivation, budgets, schedule, and project estimation. What would be really useful in a book on design would be a consideration of factors as to how to actually go about estimating the person-hours takes to create a software design.

Although the book covers design very well, there are some design issues that are glossed over or absent entirely. Much of design is reflected in and constrained by the phase that comes before (requirements) and then proven by the phase that comes after (test), and also the gateways between phases (peer reviews). The material provided on requirements, peer reviews and test truly deserve further expansion, perhaps even given their own chapters and exercises.

Although the UML toolset includes entity-relation (ER) diagrams, ER diagrams are absent from this text. As ER diagrams are essential to database design, database design is also absent. The section on HCI (Human Computer Interface) is way too short for its importance.

HCI is often what the user sees first of a software product, and first impressions are important. The quality of the user interface might just be how the user judges the overall quality of the software. Speaking of quality, the topic of software quality is addressed minimally—as a set of quality attributes, not as a strict definition, nor as an exploration of users’ perception.

Another improvement would be in identifying attributes of problems that lead to selecting appropriate design components. I remember back in the day learning new software concepts but then misapplying those concepts in the real world because of inexperience, discovering too late that the solution did not match the needs of the problem. Imagine if you will, learning hammers and then seeing everything else as a nail.

Yet one more facet of design the author might have chosen to explore but did not is design for large projects with distributed project teams. Certainly relevant to today’s globally oriented world of software development, these kinds of projects necessarily emphasize different features than do small projects, for example the issues of interface design, prototype design, test design, and configuration management move from side-issues to issues of extreme importance. Here debuggability becomes a critical architectural issue when the software being debugged is large, complex, distributed, and developed by separate teams.

To sum up, the intent of this book is educational on the topic of software design with emphasis on UML, software patterns and object oriented programming. There is also enough software engineering material that makes this text also appropriate for use in a software engineering, object oriented or software patterns lab course.

But the number of exercises provided are few—an instructor will have to add additional examples or have a lab project already in mind to go along with the text. This textbook may not be perfect but an imaginative instructor should find it to be good enough.

Perhaps the only problem with writing a textbook on design is that there is such a wealth of material that no one textbook could hope to cover it all.