Using UML : Software Engineering with Objects and Components

by Stevens, Perdita

• ISBN13: 9780321269676
• ISBN10: 0321269675
• Edition: 2nd
• Format: Paperback
• Copyright: 2006-02-03
• Publisher: Addison-Wesley

Summary

Completely updated with the new and expanded UML 2.0 standard, this is the ideal introduction to the Unified Modelling Language.

Author Biography

Perdita Stevens is a Reader in the School of Informatics at the University of Edinburgh Rob Pooley is a Professor in the School of Mathematical and Computer Sciences at Heriot-Watt University in Edinburgh

Table of Contents

Preface	xvi
First edition acknowledgments	xxi
Part I Conceptual background	1	(54)
Software engineering with components	2	(12)
What is a good system?	2	(1)
Do we have good systems?	3	(3)
Problems . . .	3	(1)
. . . even drastic failures	4	(1)
Promises, promises	5	(1)
What are good systems like?	6	(7)
Encapsulation: low coupling	7	(3)
Abstraction: high cohesion	10	(1)
Architecture and components	11	(1)
Component-based design: pluggability	12	(1)
How are good systems built?	13	(1)
Object concepts	14	(13)
What is an object?	14	(6)
Example	15	(1)
Messages	16	(1)
Interfaces	17	(1)
Classes	17	(3)
How does this relate to the aims of the previous chapter?	20	(2)
What have objects to do with components?	21	(1)
Inheritance	22	(2)
Polymorphism and dynamic binding	24	(3)
Introductory case study	27	(17)
The problem	27	(4)
Clarifying the requirements	27	(1)
Use case model	28	(3)
Scope and iterations	31	(1)
Identifying classes	32	(2)
Relations between classes	34	(2)
The system in action	36	(2)
Panel 3.1 Design by Contract I	38	(3)
Changes in the system: state diagrams	40	(1)
Further work	41	(1)
Panel 3.2 Persistence	41	(3)
The development process	44	(11)
Defining terms	44	(3)
Models and modeling languages	45	(1)
Process and quality	46	(1)
The development process	47	(5)
A unified methodology?	48	(2)
Processes to use with UML	50	(2)
System, design, model, diagram	52	(3)
The uses of models	53	(2)
Part II The Unified Modeling Language	55	(106)
Essentials of class models	56	(18)
Identifying objects and classes	56	(4)
What makes a class model good?	56	(1)
How to build a good class model	57	(2)
What kinds of things are classes?	59	(1)
Real-world objects vs their system representation	60	(1)
Associations	60	(3)
Multiplicities	62	(1)
Attributes and operations	63	(2)
Operations	64	(1)
Attributes	64	(1)
Generalization	65	(1)
Panel 5.1 Design by Contract 2 -- Substitutivity	66	(3)
Using English to check whether a generalization exists	68	(1)
Implementing generalization: inheritance	68	(1)
The class model during the development	69	(1)
CRC cards	69	(5)
Creating CRC cards	70	(1)
Using CRC cards in developing a design	70	(1)
CRC card example	71	(1)
Refactoring	72	(2)
More on class models	74	(19)
More about associations	74	(8)
Aggregation and composition	74	(2)
Roles	76	(1)
Navigability	77	(1)
Qualified associations	78	(1)
Derived associations	79	(2)
Constraints	81	(1)
Panel 6.1 OCL, the Object Constraint Language	82	(2)
Association classes	83	(1)
More about classes	84	(1)
Panel 6.2 Stereotypes	85	(3)
Interfaces	86	(2)
Abstract classes	88	(1)
Panel 6.3 Properties and Tagged Values	88	(1)
Parameterized classes	89	(2)
Dependency	91	(1)
Components and packages	91	(1)
Visibility, protection	91	(2)
Essentials of use case models	93	(11)
Actors in detail	95	(2)
Use cases in detail	97	(1)
System boundary	98	(1)
Using use cases	99	(2)
Use cases for requirements capture	99	(1)
Use cases through the development	99	(2)
Possible problems with use cases	101	(1)
Panel 7.1 Use Case Driven Development?	102	(2)
More on use case models	104	(8)
Relationships between use cases	104	(5)
Use cases for reuse: «include»	104	(2)
Components and use cases	106	(2)
Separating variant behavior: «extend»	108	(1)
Generalizations	109	(1)
Actors and classes	110	(2)
Notation: actors as classes	111	(1)
Essentials of interaction diagrams	112	(12)
Collaborations	113	(1)
Communication diagrams	114	(2)
Sequence diagrams	116	(1)
Panel 9.1 Where Should Messages Go? Law of Demeter	117	(2)
More advanced features	119	(3)
Messages from an object to itself	119	(1)
Returned values	119	(1)
Creation and deletion of objects	120	(2)
Interaction diagrams for other purposes	122	(2)
Show how a class provides an operation	122	(1)
Describe how a design pattern works	122	(1)
Describe how a component can be used	123	(1)
More on interaction diagrams	124	(8)
Beyond simple sequences of messages	124	(3)
Conditional behavior	124	(1)
Iteration	125	(2)
Concurrency	127	(5)
Modeling several threads of control	128	(4)
Essentials of state and activity diagrams	132	(13)
State diagrams	132	(7)
Unexpected messages	134	(1)
Level of abstraction	134	(1)
States, transitions, events	135	(1)
Actions	136	(2)
Guards	138	(1)
Panel 11.1 Designing Classes with State Diagrams	139	(2)
Activity diagrams	141	(4)
More on state diagrams	145	(5)
Other kinds of events	145	(1)
Other kinds of actions	146	(1)
Looking inside states	147	(2)
Concurrency within states	149	(1)
Architectural and implementation diagrams	150	(5)
Component structure diagrams	150	(2)
Deployment model	152	(1)
The physical layer	152	(1)
Deploying the software on the hardware	152	(1)
Panel 13.1 The Deployment Model in the Project	153	(2)
Packages and models	155	(6)
Packages	155	(3)
Namespace control	155	(3)
Models	158	(3)
Part III Case studies	161	(42)
CS4 administration	162	(8)
The case study	162	(6)
Class model	166	(1)
Dynamics	166	(1)
State diagrams	167	(1)
Activity diagrams	167	(1)
Discussion	168	(2)
Board games	170	(12)
Scope and preliminary analysis	171	(4)
Noughts and Crosses	171	(1)
Chess	172	(3)
Interaction	175	(3)
Back to the framework	178	(2)
States	180	(2)
Discrete event simulation	182	(21)
Requirements	182	(2)
More detailed description	183	(1)
Outline class model	184	(1)
Use cases	185	(3)
Summary of create model	187	(1)
Summary of observe behavior	187	(1)
Summary of collect statistics	187	(1)
Summary of run a model	188	(1)
Standard mechanism for process-based simulation	188	(1)
Associations and navigability	189	(3)
Classes in detail	192	(5)
Class Scheduler	193	(1)
Class ActiveEntity	193	(2)
Class PassiveEntity	195	(1)
Class Resource	195	(2)
Class Report	197	(1)
Class Statistic	198	(1)
Class Average	198	(1)
Building a complete simulation model	199	(1)
The dining philosophers	199	(4)
Part IV Towards practice	203	(38)
Reuse: components, patterns	204	(13)
Practicalities of reuse	204	(1)
What can be reused, and how?	204	(1)
Panel 18.1 What is a Component Really? Controversial!	205	(6)
Why reuse?	207	(1)
Why is reuse hard?	207	(1)
Which components are genuinely reusable?	208	(1)
What about building your own components?	209	(1)
What difference does object orientation make?	210	(1)
Design patterns	211	(4)
Example: Facade	213	(1)
UML and patterns	214	(1)
Frameworks	215	(2)
Product quality: verification, validation, testing	217	(12)
Quality review	217	(1)
How can high quality be achieved?	218	(1)
Focus on the product	218	(1)
Focus on the process	218	(1)
Further reading	218	(1)
Verification	218	(2)
Validation	220	(1)
Usability	220	(1)
Testing	221	(5)
Choosing and carrying out tests	222	(2)
Special problems of object orientation	224	(2)
Why is testing so often done badly?	226	(1)
Reviews and inspections	226	(3)
Problems of FTRs	227	(2)
Process quality: management, teams, QA	229	(12)
Management	229	(4)
Project management	230	(1)
Estimating an iterative project	231	(1)
Managing component-based development	232	(1)
People management	232	(1)
Teams	233	(1)
Leadership	234	(2)
Reform of development process	235	(1)
Quality assurance	236	(2)
Quality assurance for iterative projects	237	(1)
Total Quality Management	237	(1)
Panel 20.1 Quality Assurance: The Case Against	238	(1)
Further reading	239	(2)
Bibliography	241	(4)
Index	245