Object-Oriented Software Engineering: An Agile Unified Methodology

by David C. Kung

Object-Oriented Software Engineering: An Agile Unified Methodology, presents a step-by-step methodology - that integrates Modeling and Design, UML, Patterns, Test-Driven Development, Quality Assurance, Configuration Management, and Agile Principles throughout the life cycle. The overall approach is casual and easy to follow, with many practical examples that show the theory at work. The author uses his experiences as well as real-world stories to help the reader understand software design principles, patterns, and other software engineering concepts. The book also provides stimulating exercises that go far beyond the type of question that can be answered by simply copying portions of the text.

Contents

Preface

PART I: Introduction and System Engineering
1. Introduction
2. Software Process and Methodology
3. System Engineering

PART II: Analysis and Architectural Design
4. Software Requirements Elicitation
5. Domain Modeling
6. Architectural Design

PART III: Modeling and Design of Interactive Systems
7. Deriving Use Cases from Requirements
8. Actor-System Interaction Modeling
9. Object Interaction Modeling
10. Applying Responsibility-Assignment Patterns
11. Deriving a Design Class Diagram
12. User Interface Design

PART IV: Modeling and Design of Other Types of Systems
13. Object State MOdeling for Event-Driven Systems
14. Activity Modeling for Transformational Systems
15. Modeling and Design of Rule-Based Systems

PART V: Applying Situation-Specific Patterns
16. Applying Patterns to Design a State Diagram Editor
17. Applying Patterns to Design a Persistence Framework

PART VI: Implementation and Quality Assurance
18. Implementation Considerations
19. Software Quality Assurance
20. Software Testing

PART VII: Maintenance and Configuration Management
21. Software Maintenance
22. Software Configuration Management

PART VIII: Project Management and Software Security
23. Project Management
24. Software Security

APPENDICES
A. Personal Software Process: Estimation, Planning and Quality Assurance
B. Java Technologies
C. Software Tools
D. Project Descriptions

References
Index

720 pages, Hardcover

First published February 1, 2013

Reviews

[Alejandro Teruel · Rating 4 out of 5]

I like this book and would certainly consider it for use in one or two undergraduate courses in software engineering. There are a number of important decisions to make when teaching an undergraduate course in software engineering: (1) do you want to teach a general course or one specifically tailored to object-oriented software engineering, (2) how agile do you want to go, ((3) how far do you want to go into formal methods, (3) how specific do you want to be when tackling tools or programming languages?

Kung strikes a very interesting and quite pragmatic balance. First of all he adopts a general agile methodology which takes into account the main features of many agile methodologies and eschews trying to provide the nitty-gritty differences beween the many different flavors or variations of agile processes. In general, this is not a reference book like Sommerville or Pressman's mammoth and excellent coverages of software engineering, so Kung tends to cut to the chase providing just a couple of key methods or variations. He opts to cover far more material than is usual for an object-oriented text-book and so includes important chapters on system engineering, analysis and architectural design, domain modeling, overviews of modeling and design for event-driven, transformational and rule-based systems, software quality assurance, maintenance, project management and software security. One of the most interesting features of his book is that he is always careful to point to those aspects of modeling, analysus, design, implementation, testing or quality assurance specifically related to object-oriented software development whiel provided anogh coverage of topics to grasp or at least point to how these topics are covered in less agile processes. Every chapter includes a thoughtful section on "Applying Agile Principles”, a somewhat skimpy section on “Tool Support”, very relevant and carefully selected further readings and exercises whose level is, in general more oriented to readers with advanced critical skills.

The author is quite pragmatic and chooses to skip formal methods. For an excellent object-oriented software engineering book with a much more formal approach, I would strongly recommend at least the second edition Bruegge and Dutoit's “Object-Oriented Software Engineering: Using UML, Patterns and Java”. Kung covers a lot of key design patterns in the book and he provides snippets of Java code to illustrate the key points about how to implement them. Many of the tools he references are Java-based tools.

His chapter on Software Process and Methodology, and indeed many other chapters, emphasizes software development as a wicked problem and includes, briefly and clearly, not only the waterfall process, a prototyping and evolutionary process, Boehm's spiral process and the Unified Process as would be expected but also surprising and interestingly includes Wtt Humphries Personal Software Process (PSP) and Team Software Process (TSP) before going into agile processes where he briefly touches on the agile unified method used in the rest of the book, comparing it to the Dynamic Systems Development Method (an early 1990s UK alternative to Rapid Application Develoment), Scrum, Feature Driven Development and XP, each of which is summed up in at most a page of text.

I particularly liked his chapters on System Engineering (3), Architectural Design (6 – nice undergraduate introduction to the topic), applying patterns to design a persistence framework (17), software quality assurance (19 -this chapter includes interesting and well-justified OO metrics, although it must be said that Kung slips a little in this chapter and uncharacteristically includes too many conventional and far less relevant metrics), software testing (20 -one of the best and most condensed introductions to unit testing I have come across -even though his section ontesting for nonfunctional requirements is too cursory for my taste), maintenance (21 -one of the best introductory chapters on OO maintenance I have come across), software project management (23 -nice, brief-a pity several of the estimation methods do not include some sort of rationale, justification or evaluation) and software security (24 -an outstanding introduction to the topic in the context of a general textbook on OO software engineering). Such important topics as coupling and cohesion are well- and pragmatically introduced and adapted to object-oriented systems.

Less successful chapters include, in my opinion the one on user interfaces (12), some -but certainly not all!- of the chapters on patterns (e,g, chapter 16 on applying patterns to design a state diagram editor), the section on pair programming (18.5), the lack of refactoring methods (refactoring is barely ina couple of lines in chapter 18), configuration management (because it does not include distributed configuration management a la GIT).

All in all, a very worthy, well focused and precise addition to the field, still very relevant in spite of its 2014 publication date.