Model-Based Development: Applications

Model-Based Development: Applications

by H.S. Lahman

NOOK Book(eBook)

$48.99 $51.99 Save 6% Current price is $48.99, Original price is $51.99. You Save 6%.
View All Available Formats & Editions

Available on Compatible NOOK Devices and the free NOOK Apps.
WANT A NOOK?  Explore Now


A Proven Development Methodology That Delivers On the Promise of Model-Based Approaches

Software continues to become more and more complex, while software consumers’ expectations for performance, reliability, functionality, and speed-to-market are also growing exponentially. H. S. Lahman shows how to address all these challenges by integrating proven object-oriented techniques with a powerful new methodology.


Model-Based Development represents Lahman’s half century of experience as a pioneering software innovator. Building on Shlaer-Mellor’s work, Lahman’s unique approach fully delivers on the promise of models and is firmly grounded in the realities of contemporary development, design, and architecture.

The book introduces the methodology’s core principles, showing how it separates each of a project’s concerns, enabling practitioners to optimize each domain for its unique needs and characteristics. Next, it demonstrates how to perform more effective object-oriented analysis, emphasizing abstraction, disciplined partitioning, modeling invariants, finite state machines, and efficient communications among program units.


Coverage includes

  • How we got here: a historical perspective and pragmatic review of object principles
  • Problem space versus computing space: reflecting crucial distinctions between customer and computer environments in your designs
  • Application partitioning: why it matters and how do it well
  • Building static models that describe basic application structure
  • Modeling classes, class responsibilities, associations, and both referential and knowledge integrity
  • Creating dynamic models that describe behavior via finite state machines
  • Successfully using abstract action languages (AALs) and action data flow diagrams (ADFDs)


Throughout, Lahman illuminates theoretical issues in practical terms, explaining why things are done as they are, without demanding rigorous math. His focus is on creating implementation-independent models that resolve functional requirements completely, precisely, and unambiguously. Whether you’re a developer, team leader, architect, or designer, Lahman’s techniques will help you build software that’s more robust, easier to maintain, supports larger-scale reuse, and whose specification is rigorous enough to enable full-scale automatic code generation.

Product Details

ISBN-13: 9780132757188
Publisher: Pearson Education
Publication date: 06/14/2011
Sold by: Barnes & Noble
Format: NOOK Book
File size: 10 MB

About the Author

H.S. Lahman wrote his first software program on a plug board in 1957. That was such a character-building experience that he spent the next decade as an exploration geophysicist working in the free world’s major swamps, deserts, tundras, and jungles. Lahman then returned to school to learn about economics, operations research, and computing. For the next three decades he developed software in MIS, scientific, and R-T/E environments. Starting in 1982, he became a pioneering advocate of object-oriented development and other software quality and development process innovations.

Table of Contents

Preface           xiii

Acknowledgments          xix

About the Author         xxi

Introduction           xxiii


Part I: The Roots of Object-Oriented Development          1

Chapter 1: Historical Perspective          3

History     3

Structured Development     5

Technical Innovation    17


Chapter 2: Object Technology         29

Basic Philosophy  30

Breadth-First Processing (aka Peer-to-Peer Collaboration)   44


Chapter 3: Generalization, Inheritance, Genericity, and Polymorphism        53

Generalization    54

Inheritance     56

Polymorphism    57

Genericity    61


Chapter 4: MBD Road Map        63

Problem Space versus Computing Space    63

Maintainability    69


Chapter 5: Modeling Invariants         77

So Just What Is Modeling Invariants?     78

The Rewards    81

Examples   84


Chapter 6: Application Partitioning         105

Why Do We Care?    105

Basic Concepts of Application Partitioning    107

Identifying Subsystems     119

Bridges   122

Describing Subsystems    127

An Example: Pet Care Center   130

Processes   145


Part II: The Static Model          151

Chapter 7: Road Map to Part II         153

What Is the Static Model?     154

Knowledge versus Behavior    156

Practical Note   158


Chapter 8: Classes         161

Abstract Representation    161

Class Notation    167

Identifying Classes and Their Responsibilities    169

Examples   172

Using Sequence and Collaboration Diagrams    186


Chapter 9: Class Responsibilities         191

Attributes: What the Objects of a Class Should Know   191

Operations and Methods: What an Object Must Do    197

Process    207

Examples   209


Chapter 10: Associations         233

Definitions and Basics    234

Notation    239

The Nature of Logical Connections   242

Conditionality     250

Multiplicity     255

Constraints    261

Association Classes     264

Identifying Associations     269

Examples    273


Chapter 11: Referential and Knowledge Integrity             279

Knowledge Integrity     280

Referential Integrity     289


Chapter 12: Generalization Redux          299

Subclassing     300

Multi-directional Subclassing, Multiple Inheritance, and Composition     317

Alternatives to Generalization    328


Chapter 13: Identifying Knowledge           333

What Is the Nature of OO Knowledge?     334

Abstracting Aggregates    335

Picking the Right Abstraction    341

Does the Abstraction Need to Coalesce Entity Knowledge?    351


Part III: The Dynamic Model         355

Chapter 14: Road Map to Part III         357

Part III Road Map    357

Action Languages    373

Mealy versus Moore versus Harel     374

The Learning Curve    376


Chapter 15: The Finite State Machine           377

Basic Finite State Automata    378

Looking for State Machines    390

Some Examples    407


Chapter 16: States, Transitions, Events, and Actions          415

States    415

Transitions     421

Events     423

Actions     427

The Execution Model     430

Naming Conventions     433


Chapter 17: Developing State Models          437

Designing State Machines     437

Examples   . 450


Chapter 18: Abstract Action Languages          475

AALs and ADFDs     476

AAL Syntax    478

Examples    480


Glossary           489

Index        501

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews

Model-Based Development: Applications 5 out of 5 based on 0 ratings. 1 reviews.
jreeze More than 1 year ago
Coming from an Agile (XP) background, I would have easily dismissed the book just because it had "model-based" in its title. However, I had long been frustrated by the quality of the designs I produced despite following XP practices such as TDD and trying to apply SOLID object-oriented design principles. I thought I might learn a thing or two about design/domain modeling since the book seems to be written by someone from the "modeling camp". I did. The book exceeded my expectations and broke my pre-conceived notions about model-based development. Further, it turns out that the book isn't just for practitioners of model-based methodologies. Apart from a software development methodology such as XP, developers need an analysis and design methodology to guide thinking about a problem and provide a set of practices/guidelines that show HOW to apply established design principles when crafting a solution. This is exactly what the book provides - an object-oriented analysis and design methodology. It clearly explains what problem OO technology addresses and how it does it. It reveals that OO is not necessarily the appropriate approach in all situations and helps the reader recognize when this is so. It also provides a comprehensive discussion of OOAD from partitioning subject matters to finding objects and defining their relationships and interactions. More than that, the book has revealed insights on OO I have not been exposed to since I started learning about OO. The author talks about how business rules can be encoded in static structures rather than in executable program statements. He talks about encoding invariants and leaving differences to external data. Of course, these not only serve to satisfy aesthetic sensibilities the author might have but have actual practical value: reducing code complexity (in terms of the number of executable statements and decisions) to reduce opportunities for inserting defects. That being said, this is not a "for dummies" book. Readers who have been trained in OO by learning an OO programming language will likely find the ideas quite novel. Aside from diligence, an open mind and a willingness to unlearn old habits and pre-conceptions about OO technology is required. The return is a more mature and upgraded skill not only in object orientation but in the general practice of software analysis, design, and development.