Object Oriented Analysis and Design using UML
System architects, system engineers, developers and analysts / programmers with at least
two years experience, preferably in a modern object-oriented language (Java, C #, Ruby ...).
This UML course is intended for system architects, analysts / programmers and developers
who wish to define system requirements using use cases, object-oriented model released
from implementation details and realized from the foregoing requirements and a model of
architecture layer, based on components that maximize the maintainability and reuse of
The best modeling techniques are based on the Unified Modeling Language 2.1 and are well
rooted in a software development process focused on the (model-driven) paradigm.
Understanding the concepts covered is continually tested and improved through classroom
exercises and workshops based on examples from real projects using appropriate CASE tools.
At the end of the course
Specify functional requirements through the Use Cases
- Definition of Unified Modeling Language (UML 2.1)
- The modeling process
System use cases and actors
Writing effective use cases
Realization of subflows and alternative flows
Relations of inclusion and extension
Relations of generalization
Use Case workshop
Objects and classes
- Information gathering
- Mapping business requirements
- Estimates and traceability process
- Incremental and Iterative development
- Requirements documentation
- Workshop on requirements gathering
Relations between objects
- Il concetto di Oggetto in informatica
- Difference between Classes and Objects
- Attributes, operations and methods
- Responsability concept in a class (CRC)
- Workshop on classes and objects
- Associations and links
- Navigability and multiplicity
- Aggregation and composition
- Workshop on relations among objects
- Sequence Diagrams
- Selection and iteration in diagrams
- Comunication Diagram
- Workshop on interaction model
- Significance of the state model
- States and transitions
- Events and conditions
- Actions and activities
- Activity Diagrams
- Congruence with other models
- Workshop on the state model
Diagrams of components, architecture and implementation
- Creating a conceptual object model
- CRC cards technique
- Events and conditions
- Coupling, cohesion and coherence
- Iterative and incremental model
- Prototyping and modeling cycle
- Refinement and completion of the model
- Workshop basato sull'analisi di sistema
Relationship between classes and inheritance
- Packages and dependencies
- Control objects
- Design of Control Flow
- Different types of architectures (client server, peer to peer, pipe and filter, ...)
- Interfaces, subsystems and components
- Component diagrams
- Deployment diagrams
- Workshop on system architecture
Domain Driven Design (DDD)
- Syntax generalization
- Distinction between the concepts "is a" and "has a"
- Multiple inheritance
- Dependency among classes
- Workshop on generalization and class relationships
- Basic concepts of DDD
- What constitutes a valid model-driven design approach
- The benefits for the entire team to promote the use of DDD
- The concept of Bounded Context
- Importance of a universal and ubiquitous language
- Workshop on Domain Driven Design
- Designing subsystems
- Architectural Mechanisms
- Link to libraries and frameworks
- Traceability models
- Model Driven Architecture (MDA)
- Reverse Engineering and Round-trip
- Workshop on Detailed Design
Participants will learn:
- Terms and details of the UML 2.1 and the Object Oriented methodology.
- Creating a view summarizing the functional requirements by using actors and use cases in use case diagrams.
- How to effectively describe a system through use cases so that the model may be satisfactory for both
technical stakeholders than for non-technical ones.
- How to restructure the use case diagram to handle complex relationships between use cases without getting a mesy use case model.
- How to integrate the use case model with non-functional requirements, data requirements, business rules and prototypes of user interfaces.
- How to create a detailed model of system data using the classes and their relationships.
- How to map the functionality of the system requirements in the object model using sequence diagrams.
- How to structure the model in the form of implementation of use cases.
- How to model the dynamics of data and functionality of the system using state diagrams.
- How to model at a consistent level of abstraction.
- As the model created during analysis system combines with an incremental process of model-driven development.
- How to develop a flexible system architecture from an object model analysis.
- How to develop component and deployment models for the system.
- How to shape the design of a component by using sub-systems and interfaces.
- How to create libraries of reusable classes using generalization and inheritance.
- How to model the use of technology and frameworks as a set of design patterns.
- How to integrate libraries and frameworks in the design of components.
- How to generate frame code and maintain design models and code synchronized.
- How to specify, analyze, design, build, test and release components as part of a
process of incremental model-driven development.
Theoretical and practical, or course elements will alternate theoretical illustration of specific
cases and demonstration of the UML methodology.
Delivery will be based on practical-exercises, for which the exercises will be balanced on the
basis of the relevance of the topics covered.
5 days full time (9.30 - 13.00) (14.00 - 17.00)