Using UML : Software Engineering with Objects and Components

by Stevens, Perdita

• ISBN13: 9780201648607
• ISBN10: 0201648601
• Edition: Revised
• Format: Paperback
• Copyright: 2006-01-01
• Publisher: Addison Wesley

Summary

The essentials of UML 2.0 and how to use it in one concise volume.

Author Biography

Dr. Perdita Stevens lectures in the Computer Science department at the University of Edinburgh.

Table of Contents

Preface	xvi
Acknowledgments	xx
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	(2)
Use case model	29	(2)
Scope and iterations	31	(1)
Identifying classes	32	(2)
Relations between classes	34	(2)
The system in action	36	(3)
Design by Contract I	39	(3)
Changes in the system: state diagrams	41	(1)
Further work	41	(1)
Persistence	42	(2)
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?	49	(1)
Processes to use with UML	50	(2)
System, design, model, diagram	52	(3)
PART II The Unified Modeling Language	55	(114)
Essentials of class models	56	(18)
Identifying objects and classes	56	(4)
What makes a class model good?	57	(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	63	(1)
Attributes and operations	63	(2)
Operations	64	(1)
Attributes	64	(1)
Generalization	65	(1)
Design by Contract 2: substitutivity	66	(3)
Using English to check whether a generalization exists	67	(1)
Implementing generalization: inheritance	67	(2)
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	(9)
Aggregation and composition	74	(2)
Roles	76	(1)
Navigability	77	(1)
Qualified associations	78	(1)
Derived associations	79	(2)
Constraints	81	(2)
OCL, the Object Constraint Language	83	(2)
Association classes	84	(1)
More about classes	85	(1)
Stereotypes	86	(3)
Interfaces	86	(2)
Abstract classes	88	(1)
Properties and tagged values	89	(1)
Parameterized classes	90	(1)
Dependency	91	(1)
Components and packages	91	(1)
Visibility, protection	92	(1)
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)
Use case driven development?	102	(2)
More on use case models	104	(9)
Relationships between use cases	104	(5)
Use cases for reuse: «include»	104	(3)
Components and use cases	107	(1)
Separating variant behavior: «extend»	108	(1)
Generalizations	109	(1)
Actors and classes	110	(3)
Notation: actors as classes	111	(2)
Essentials of interaction diagrams	113	(15)
Collaborations	114	(1)
Interactions on collaboration diagrams	115	(2)
Sequence diagrams	117	(1)
Where should messages go? Law of Demeter	118	(2)
More advanced features	120	(6)
Messages from an object to itself	120	(1)
Suppressing detailed behavior	120	(2)
Returned values	122	(1)
Creation and deletion of objects	122	(3)
Timing	125	(1)
Interaction diagrams for other purposes	126	(2)
Show how a class provides an operation	126	(1)
Describe how a design pattern works	127	(1)
Describe how a component can be used	127	(1)
More on interaction diagrams	128	(10)
Generic interaction diagrams	128	(3)
Conditional behavior	129	(2)
Iteration	131	(1)
Concurrency	131	(7)
Modeling several threads of control	133	(5)
Essentials of state and activity diagrams	138	(12)
State diagrams	139	(5)
Unexpected messages	140	(1)
Level of abstraction	140	(1)
States, transitions, events	141	(1)
Actions	142	(1)
Guards	143	(1)
Designing classes with state diagrams	144	(2)
Activity diagrams	146	(4)
More on state and activity diagrams	150	(5)
Other kinds of events	150	(1)
Other kinds of actions	151	(1)
Looking inside states	152	(1)
Concurrency within states	153	(2)
Implementation diagrams	155	(7)
Component model	156	(2)
Summary: classifiers and instances	158	(1)
Deployment model	159	(1)
The physical layer	159	(1)
Deploying the software on the hardware	160	(1)
The deployment model in the project	160	(2)
Packages, subsystems, models	162	(7)
Packages	162	(4)
Namespace control	164	(2)
Subsystems	166	(1)
Models	167	(2)
PART III Case studies	169	(42)
CS4 administration	170	(8)
The case study	170	(5)
Class model	174	(1)
Dynamics	174	(1)
State diagrams	175	(1)
Activity diagrams	175	(1)
Discussion	175	(3)
Board games	178	(12)
Scope and preliminary analysis	179	(4)
Noughts and Crosses (Tic-Tac-Toe)	179	(1)
Chess	179	(4)
Interaction	183	(3)
Back to the framework	186	(2)
States	188	(2)
Discrete event simulation	190	(21)
Requirements	191	(1)
More detailed description	191	(1)
Outline class model	192	(1)
Use cases	193	(4)
Summary of create model	193	(1)
Summary of observe behavior	194	(1)
Summary of collect statistics	194	(2)
Summary of run a model	196	(1)
Standard mechanism for process based simulation	197	(1)
Associations and navigability	198	(3)
Classes in detail	201	(5)
Class Scheduler	201	(1)
Class ActiveEntity	202	(1)
Class PassiveEntity	203	(1)
Class Resource	204	(2)
Class Report	206	(1)
Class Statistic	206	(1)
Class Average	207	(1)
Building a complete simulation model	207	(1)
The dining philosophers	208	(3)
PART IV Towards practice	211	(38)
Reuse: components, patterns	212	(13)
Practicalities of reuse	212	(1)
What can be reused, and how?	212	(1)
What is a component really? Controversial!	213	(6)
Why reuse?	215	(1)
Why is reuse hard?	215	(2)
Which components are genuinely reusable?	217	(1)
What about building your own components?	217	(1)
What difference does object orientation make?	218	(1)
Design patterns	219	(5)
Example: Facade	221	(1)
UML and patterns	222	(2)
Frameworks	224	(1)
Product quality: verification, validation, testing	225	(12)
Quality review	225	(1)
How can high quality be achieved?	226	(1)
Focus on the product	226	(1)
Focus on the process	226	(1)
Further reading	226	(1)
Verification	227	(1)
Validation	228	(1)
Usability	228	(1)
Testing	229	(5)
Choosing and carrying out tests	230	(2)
Special problems of OO	232	(2)
Why is testing so often done badly?	234	(1)
Reviews and inspections	234	(3)
Problems of FTRs	235	(2)
Process quality: management, teams, QA	237	(12)
Management	237	(4)
Project management	238	(1)
Estimating an iterative project	239	(1)
Managing component based development	240	(1)
People management	241	(1)
Teams	241	(1)
Leadership	242	(2)
Reform of development process	244	(1)
Quality assurance	244	(2)
Quality assurance for iterative projects	245	(1)
Total Quality Management	246	(1)
Quality assurance: the case against	246	(1)
Further reading	247	(2)
Bibliography	249	(3)
Index	252