Stanley Kubasek has been a Java software developer in the NY/NJ area for the past 7 years. He maintains a software blog, The Pragmatic Craftsman, available from his site http://kubasek.com.
The Rich Engineering Heritage Behind Dependency Injection
Andrew McVeigh takes us on a tour of the rich heritage behind dependency injection, what it represents, and tells us why its here to stay.
NetBeans 6: Matisse Updates
NetBeans 6 delivers great updates to the Matisse GUI builder. Spend a few minutes with Roman Strobl and get an expert briefing on what's new and what has changed. (sponsored)
Introduction to Groovy Part 3
In this, the third and final installation of Andres' Introduction to Groovy series, you learn about how Groovy handles variable numbers of arguments, named parameters, currying, and more about Groovy operators. Including, some new operators.
Easier Custom Components with Swing Fuse
Swing Fuse (actually just Fuse), is a framework designed to make it easier to create your own custom desktop components. In this article, Daniel Spiewak shows you how to get started and provides sample source code you can download.
Benchmark Analysis: Guice vs Spring
Willam Louth shows how he uses JXInsight Probes to investigate probable performance issues with code bases that he is not familiar with. He also highlights possible pitfalls in creating a benchmark, as well as in the analysis of results.Object-Oriented Analysis and Design with Applications
| Author(s) | Grady Booch, Robert A. Maksimchuk, Michael W. Engel, Bobbi J. Young, Jim Conallen, Kelli A. Houston |
|---|---|
| Publisher | Addison Wesley |
| PubDate | 2007, 3rd Edition |
| Reviewer | Stanley Kubasek |
 |
Purchase and help Javalobby |
Table of Contents
|
One Minute Review
Positives |
Sections
Intent & Audience
This book is written for the computer professional as well as for the student.
As a systems or software developer, you can learn how to effectively use object-oriented technology to solve problems.
As an architect or an analyst, you can learn how to proceed from requirements to implementation using object-oriented analysis and design. You will learn what a "good" architecture is, and get some very good insight how to manage software complexity.
As an program manager, you can learn how to allocate resources of a team of developers and how to manage risks associated with complex software systems.
Back to topRelevance of material
I had heard about this book a long time ago. The 3rd edition was delayed for years. I finally received it and I think it was worth the wait.
This book covers UML 2.0, which is a fairly recent revision of the language. Knowing UML is very important when you are dealing with complex systems, and the authors do a great job explaining UML.
If you are interested in object-oriented analysis and design, this is the book to get. Besides UML, it covers Use Cases, the Unified Process and most if not all artifacts that should be created. Most of all, it gives you ideas on how you should proceed, what you should and should not be doing. This is a very valuable information – especially valuable when you want to do things right.
Chapter highlights
Section I: Concepts
Chapter 1: Complexity
In this chapter, the authors explain the benefits of using OOAD to master the complexity, with the use of decomposition and abstraction.
It is a joy to read numerous examples and real world analogies of everyday objects to complex systems.
The authors give supporting arguments as to why software is complex, and how humans can only comprehend a few things (7) at a time.
Chapter 2: The Object Model
In this chapter, the object model is presented as the means to help manage software complexity. Fundamental elements of the object model are explained: abstraction, encapsulation, modularity, and hierarchy.
Very good classification of programming languages is presented as well. It lists several generations of programming languages. Different paradigms are explained: procedure oriented, object-oriented, logic-oriented, rule-oriented, and constraint-oriented.
The authors present the best in its kind, in my opinion, definition of abstraction. The discussion on it, and also on encapsulation, modularity, and hierarchy, filled with excellent examples is great.
Chapter 3: Classes & Objects
In this chapter, the authors answer what object is, and what it isn't. They talk about the state, behavior, identity, and relationships among objects. The authors also talk about classes and the different types of relationships among them: generalization/specialization, whole/part, and association.
Coupling, cohesion, sufficiency, completeness, and primitiveness: the five fundamental metrics to qualify classes and objects are explained.
This chapter contained a lot of fundamental knowledge about classes and objects. The amount of detail is excellent. However, the presentation of the material could be improved. I thought this was a fairly dry chapter, hard to keep focus when reading – it's not an exciting chapter to read.
Chapter 4: Classification
In this chapter, the authors presented ways to identify classes and objects relevant to a particular problem. It is not an easy task, as the authors point out, because there is no "perfect" solution, and it requires a great amount of creative insight.
Object Oriented Analysis methods are explained. The authors give an overview of the classical behavior, domain and use case analysis. CRC cards are also briefly explained.
Similar to the last chapter, a lot of information was presented in this chapter. To me, this was a little bit too much theory, and not enough examples.
Section II: Method
Chapter 5: Notation (UML 2)
A detailed, very well organized reference on UML 2.0 is contained in this chapter. Very good explanations.
This is probably as good a reference on UML that you will find. Plus, it is very concise. Clear explanation, good examples – covers what's necessary.
Chapter 6: Process
In this chapter, the authors discuss the overall software development process: its life cycle. A clear explanation of what an iterative and incremental process is, what artifacts are produced, milestones, and more.
This chapter also contains a great section on architecture. The authors present an excellent introduction and explanation of what architecture is and what are some of the qualities of a good architecture. Great stuff.
Chapter 7: Pragmatics
Management issues/tasks are discussed in this chapter. The authors provide good suggestions on how to do risk management, task planning, reviews, and how to manage staffing. This section on staffing is excellent, it explains how a project should be staffed, how to allocate people, and what different people with different skills should do.
The authors also cover release management, reuse, documentation, tools and some other metrics that can be used when doing OO development.
Very practical chapter. Many of the suggestions can be implemented in a software development process.
Section III: Applications
In this section, a new application is developed in each chapter. However, focus of each chapter shifts: first application is mostly based on requirements, and the last is mostly concerned about construction.
Chapter 8: System Architecture: Satellite-Based Navigation
In this chapter, the authors implement and discuss the problem of designing the first and second levels of the architecture. Only a small subset of artifacts is actually developed. The main focus is to go through the first iteration of the life cycle, where the requirements are analyzed and a working architecture is developed. Several UML diagrams are developed and explained in this chapter.
Chapter 9: Control System: Traffic Management
As in the previous application, all phases of the iteration are covered, Inception, Elaboration, Construction, and Post-Transition. The focus of this chapter is still in the requirements engineering, developing use cases, diagramming scenarios, and simple sequence diagrams and class diagrams.
Chapter 10: Artificial Intelligence: Cryptanalysis
In this chapter, the authors move more into the analysis and construction phase. The problem at hand is to design a solution to the cryptanalysis problem, explained in the beginning of the chapter, using the blackboard formula. Excellent analysis of the problem. Very good explanations on how to come up with classes and responsibilities, as well as creating class diagrams. This is a very good chapter for typical programmers. 
Chapter 11: Data Acquisition: Weather Monitoring System
A hands on, practical chapter, with actual code examples. The Weather Monitoring System is developed in this chapter. The system uses sensors and devices that measure the weather conditions that are analyzed and displayed. Focus of chapter is on Use Case analysis - several use cases are analyzed - and also on class design and diagrams.
Chapter 12: Web Application: Vacation Tracking System
In this chapter, an enterprise application is developed. The focus of this chapter is on the underlying technologies, filled with actual code examples. Requirements are briefly discussed in the Inception and Elaboration phase, and the meat of the chapter is in the Construction phase. Usage graphs, patterns and technologies used are discussed (ie., EJB, MVC, SDO, Session Facade, and more). Also, a walk through of the actual web development is presented.
Rating
The information contained in this book is excellent. It has everything that you will if you want to adapt the Unified Process, learn UML 2.0, and do object oriented analysis and design. However, it is a very theoretical book, which makes it hard to read – hard to stay focused at times. Nonetheless, it is a very important book.
| Relevance |   |
|---|---|
| Readability | |
| Overall | |
Resources
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development - in my opinion, the best book on OOAD
UML Distilled - the most popular UML book
