This award-winning book covers how the entire object-oriented development process works. You will gain a detailed understanding of all phases of OO development in a coherent and consistent manner.
Building Object Applications That Work starts exactly where The Object Primer 1st Edition left off — At OO design. Like The Object Primer it is written in everyday language that you can understand, covering leading-edge topics that are pertinent to real-world developers. While OO is often used to develop complex systems, OO itself does not need to be complicated. Like The Object Primer this book is written from the point of view of a developer, somebody who has lived through the difficulty of learning this exciting new approach to creating applications.
This book takes you through the entire process of building object applications, from analyzing the project, to designing a user-friendly interface, to testing your approaches to make sure your applications work properly. It includes sections on:
- How to use the Unified Modeling Language effectively
- Analysis, so you know what you need to build
- Design techniques, so that you know how you are going to build your application
- Collecting the right metrics to improve your development approach
- Applying OO patterns to improve the quality of your applications
- Creating applications for stand-alone, client/server and distributed environments
- Using both relational and object-oriented databases to make your objects persistent
- Architecting your applications so they are maintainable and extensible
Published: February 1998
Status: Out of date
Where to Buy This Book:
- Brazilian Portuguese (no longer available)
What You Will Learn
By reading Building Object Applications you will gain a thorough understanding of how the entire object-oriented development process works. Furthermore you will gain a detailed understanding of all phases of OO development in a coherent and consistent manner.
Building Object Applications That Work is divided into five parts:
Part 1 — Introduction
Building Object Applications starts where The Object Primer left off — At OO design. Well, actually it starts with a review of, and a few improvements to, The Object Primer. To keep things simple I purposely left out a few things in the first volume, specifically class methods and class attributes. These two concepts are just too darn confusing for OO beginners, so I skipped them until this book. Besides, I wanted to make sure there was enough new stuff in the first chapter to make it worth your while to read it. I also transition from the Ambler Notation presented in The Object Primer to the Unified Modeling Language (UML), which is quickly becoming the industry standard.
Part 2 — Object-Oriented Analysis, Design, and Architecture
In the second chapter we’ll discuss several diagramming techniques that we didn’t cover in the first book. We’ll also learn some really good tips and techniques to make your diagrams look better, as well as how to convert back and forth between the class modeling notations of the leading OO methodologies. One of the main benefits of this chapter is that you get a really solid understanding of how OO analysis and OO design techniques fit together.
Chapter 3 introduces us to an OO class type architecture. We’ll propose a four level architecture that actually has five and maybe even six levels, but who’s counting? We then get into OO patterns in chapter 4. You’ve heard a lot about them, you’ve seen the huge tomes, now it’s time to actually find out about what this stuff is really all about. Because the proof is always in the pudding, but never in the jelly for some reason, we’ll look at several patterns that are being used in live applications today.
In chapter 5 we’ll delve into distributed OO architectures — Because the client/server (C/S) architecture is currently the dominant approach to systems development, I figured we’d better show you how to design for C/S. We’ll discuss the seven steps for creating an OOC/S design. C/S can be very complex, and experience has shown that OO is the surest way to guarantee success in a C/S environment. We’ll also discuss how OOCS leads to distributed objects, an architecture that is quickly catching on and that is most likely in your future.
Part 3 — Object-Oriented Construction
Chapter 6 covers object-oriented metrics that you can use to both estimate the size of a project and to evaluate how well you are doing. The important thing about metrics for developers are the design and coding implications that they make. Understanding the basis for metrics will help you to improve your development skills.
We’re going to spend a fair bit of time talking about OO languages and OO construction issues in chapters 6 and 7, so all you programmers out there might want to skip immediately to that chapter. Although there are a fair number of OO programming languages, we concentrate on Smalltalk, C++, Java, and ObjectCOBOL in chapter 6. In chapter 6 we also discuss many of the issues surrounding electronic commerce, so you should find it interesting. We cover a lot of programming tips as well as code documentation tips in chapter 8, so I think that you’ll really like it.
Chapter 9 covers user interface design not only because it’s important, but because I’m really getting tired of using programs with interfaces that are hard to use. I begin by arguing that just because you use a GUI it isn’t necessarily OO. We’ll see designs for both a standard GUI interface for the bank and an OOUI (OO user interface) for it and when you see the difference you’ll be astounded. You’ll also learn a lot about prototyping and screen design in this chapter.
As saving objects is a reasonably common thing to do, we’re going to cover this topic in detail in chapter 10. Relational technology are the reality out there, not object databases, so for most of the chapter I’ll assume you’re trying to store your objects into a relational DB. Unfortunately, this is easier said than done. We’re going to discuss issues like OO normalization, converting objects to relational records, inheritance issues, and design issues when using a relational DB to store objects. The chapter ends with a discussion of both object/relational and object databases, what they’re all about and where they’re going. Bottom line is that object databases are an important topic that must be covered.
Chapter 11 discusses wrapping, which is a technique for getting a few more miles out of your legacy applications. If the legacy applications were horses we would have shot them long ago, but unfortunately we’ve made a huge investment in them that we’d prefer not to lose.
Part 4 — Object-Oriented Testing
Until now, OO testing hasn’t been well covered by the mainstream OO methodologies, and that’s a problem that we want to address. Users really like it when their application works, so it’s not a bad idea to test your application before you release it. The bad news is that traditional testing techniques don’t always work for OO applications. The good news is that chapter 12 describes the full lifecycle object-oriented testing (FLOOT) approach which presents a multitude of effective OO testing techniques.
Part 5 – Conclusion
This section is basically a quick wrap-up of the material covered in the book as well as some of my thoughts regarding how to successfully overcome the object-oriented learning curve.
One of the strengths of Building Object Applications That Work is that it comes with a fairly robust glossary that includes both pictures and text descriptions of them. Not only are you given the definition of a term, you often also are shown the modeling notation for that term as well.