Home > Store

Executable UML: How to Build Class Models

Register your product to gain access to bonus material or receive a coupon.

Executable UML: How to Build Class Models

Book

  • Sorry, this book is no longer in print.
Not for Sale

About

Features

  • Executable UML, in detail—Introduces the Executable UML graphical specification language, which combines a subset of UML graphical notation with executable semantics and timing rules. Executable UML can be used to build a fully executable system specification consisting of class, state, and action models that can be run, tested, debugged, optimized for performance, and translated directly into code.
    • Introduces breakthrough techniques students can use to create rigorous, testable, complete UML specifications—and dramatically improve the quality, reliability, and value of any software system. Ex.___

  • Extensive real-time and embedded application examples—Provides scientific and technical examples not found in any other UML guidebook.
    • Gives engineering and technology students unprecedented insight into UML, while at the same time offering disciplined techniques that are powerfully effective in business application design. Ex.___

  • Focused, in-depth coverage of class modeling—Covers classes, attributes, associations, relationships, binary associations, association classes, specialization-generalization relationships, model constraints and descriptions, and reflexive, network, linear, and tree patterns for effective object modeling.
    • Gives students the most detailed and sophisticated class modeling techniques available. Ex.___

  • By Leon Starr, the leading expert in building object models for real-time systems, and author of How to Build Shlaer-Mellor Object Models and Executable UML: A Case Study.
    • = Gives students state-of-the-art techniques and skills from one of the world's leading experts. . Ex.___

Description

  • Copyright 2002
  • Dimensions: K
  • Pages: 448
  • Edition: 1st
  • Book
  • ISBN-10: 0-13-067479-6
  • ISBN-13: 978-0-13-067479-1

The practical guide to developing class models with Executable UML.

In Executable UML, Leon Starr shows how to build precise class models that form the foundation of rigorous software specifications. These specifications can be tested, debugged and optimized to generate code for multiple languages and platforms. Leon presents a wide range of examples from his projects in the fields of science and engineering-focusing on real-time environments where precise and accurate software specification is especially critical.

Using the materials in his classic How to Build Shlaer-Mellor Object Models as a starting point, Leon offers an introduction to Executable UML class models, expressing all diagrams in Executable UML notation with more object modeling techniques. Coverage includes:

  • Executable UML classes and attributes
  • Associations and relationships
  • Binary associations and association classes
  • Specialization-generalization relationships
  • Loop constraints
  • Reflexive, network, linear, and tree patterns for effective object modeling

Whether you're creating technical or business applications, Executable UML gives you the tools you need to build reliable software, readily deployed on a variety of specialized hardware and software platforms.

Sample Content

Online Sample Chapter

Modeling Loops and Constraints Using Executable UML

Table of Contents



 1. Classes.


 2. Attributes.


 3. Associations And Relationships.


 4. Binary Associations.


 5. Association Classes.


 6. Basic Specialization-Generalization Relationships.


 7. Advanced Generalization Relationships.


 8. Constraints On Association And Relationships.


 9. How to Avoid Model Hacking.


10. Why Write Model Descriptions.


11. How to Write Class Descriptions.


12. How to Write Attribute Descriptions.


13. How to Write Association Descriptions.


14. Why Do We Limit Ourselves to 0, 1 and *?.


15. Reflexive Patterns.


16. Network Patterns.


17. Linear Patterns.


18. Tree Patterns.

Preface

Author's preface

This book is a collection of models, modeling tips and analysis techniques that have worked for me (and my colleagues) on real projects.It conveys the experience that I have gained in 15 years of buildingexecutable object-oriented models. I have written this book for especially for those of you who have already had an introduction to anexecutable, translation-driven modeling method such as ExecutableUML or the Shlaer-Mellor method. I presume that you are eitherabout to start applying Executable UML on your project or that youhave been building executable models for a year or two. This text isgeared toward those of you who do the hard work of boiling downapplication requirements, formalizing these requirements into fullydetailed models, and getting those models translated into workingsoftware.

This book is not a complete statement or grammar of the Executable UML language. For that please see Steve Mellor's text listed inthe "Where to learn more" section at the back of thebook. Instead, I show you some of the ways that I use important features of the object modeling language. I also provide some guidancein how to deal with a few thorny issues.

Experience on multiple projects has taught me many things. One ofthe most important lessons is that you can't skimp on the class models and get away with it. You must ensure that your applicationrequirements are thoroughly captured, in great detail, in your classmodels. This takes time and hard work. Whenever my colleaguesand I have cut corners we have run afoul of the following consequences: (1) the state charts become ridiculously complex; (2) oneor two critical requirements lie hidden until late in the modelingprocess, leading to time-consuming rework; and (3) new requirements that should have been anticipated arise late in the modelingprocess and wreak havoc. On the other hand, a good class modelleads to stable state models and simple threads of control. This bookfocuses on the key to success: building quality class models.

Like most of us, coming originally from a function-oriented programming background, learning to build class models has been challenging to say the least. I've noticed that engineers new to object-oriented analysis grapple with many of the same questions that Idid: What model structures are legal? (Can I do that with a generalization relationship?) How much detail should go into the classmodel? How do I build a model that won't fall apart when therequirements change? What's the difference between a good classmodel and a bad class model? Why do I need to write modeldescriptions? What's the best way to express an association involvinga specific number of instances (not 0, 1 or *). What's the best way tomodel a hierarchy of things? This book contains answers to thesequestions and many others.

Another big key to success is to use your time effectively. A commonmistake is to spend too much time modeling and not enough timedoing analysis. Few software engineers appreciate the value of distinguishing the activities of analysis and modeling. I don't know howmany times I've seen a novice analyst spend hours building the perfect model to suit a set of perceived requirements. Later on therequirements change, or they turn out to be the wrong requirements, or they turn out to be based on some aspect of the systemthat is so volatile that no attempt to nail down the requirements canbe successful. As a consequence the whole model unravels. I wrotePart 2 of this book to show how this kind of disaster can be avoided.

To become a good programmer, not only do you need to write a lotof code, but you also need to look at code written by other people.The same is true when it comes to analysis and modeling. Themodels in this book will give you something helpful to look at fromtime to time as you build lots of models. Have fun.

Leon Starr
San Francisco, California

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership