UML Course
Synopsis
This three day course is intended to assist delegates in developing reliable and maintainable object-oriented applications by following a software development process.
The Unified Software Development Process is adopted, in conjunction with Unified Modelling Language (UML) and
Enterprise Architect, a UML tool.
To reinforce the theory, A UML model for an e-commerce application is assembled. Following the Model-Driven Architecture
(MDA) approach, a platform independent model is initially built. This is subsequently transformed into platform specific models: Java, C# and tables in a relational database. Design patterns are discussed in the context of the generated code and unit tests are configured.
Each delegate has the use of a computer; course hours are 9:00 to 5:00. The
textbook, UML 2 and the Unified Process, is included. Lunch and refreshments are
also included.
Suitable for
The course is aimed at software developers and project managers. Some
experience in an object-oriented language such as Java or C# would
be helpful, but is not a prerequisite.
Course Content
Introduction to the Software Development Process
- The Unified Process (UP)
- Iterative development and the five UP workflows (Requirements, Analysis, Design, Implementation, Test)
- The four UP Phases (Inception, Elaboration, Construction, Transition)
- Unified Modelling Language (UML)
- UML classifiers and diagrams
Requirements
- Capturing system requirements
- Functional and non-functional requirements
- Using the XML Metadata Interchange (XMI) standard to import requirements into Enterprise Architect
- Describing requirements by use case modelling
- Detailing use cases, including main and alternate flows, pre and post conditions, branching and repetition
- Advanced use case modelling including actor generalisation, inclusion and extension use cases
- Tracing requirements to use cases
Analysis
- The purpose of the analysis workflow
- The notation of UML class diagrams
- Analysis classes and the platform independent model
- Finding classes by CRC analysis, noun/verb analysis and UML stereotypes
- Modelling associations and dependencies between classes
- Inheritance and polymorphism
- Organising classes into analysis packages
- Building UML interaction diagrams to realise use cases
- Using UML activity diagrams to graphically model the flow through a use case
Design
- Moving the focus from the problem domain to the solution domain
- The features of well-formed design classes
- Refining analysis relationships by specifying navigability, multiplicity and aggregation or composition
- Extracting interfaces from analysis classes
- Grouping elements into subsystems with required and provided interfaces
- Developing detailed interaction diagrams for the design workflow, including interaction fragments and interaction occurrences
- Modelling the changing states of an object with State Machine diagrams
|
|
Implementation
- Using MDA to transform the platform independent design model into platform
specific models (Java and C#)
- Generating source code from the platform specific models
- Compiling and executing the generated code, using the Eclipse development environment for Java and Visual Studio for C#
- Distributing the compiled code as a Java JAR file or .NET DLL
- Using UML deployment diagrams to describe the mapping between software architecture and hardware architecture
- Reverse engineering source code back into the UML model
- Transforming entity classes into Data Definition Language and creating tables in a relational database
- Exporting project documentation for the UML model
- Generating HTML documentation for Java and C# source code
Test
- Creating and running unit tests with JUnit by transforming the Java model
- Running C# unit tests with NUnit
- Adding unit test results to the project documentation
Design Patterns
- Object-oriented design principles, such as encapsulating what varies, favouring composition over inheritance and programming to interfaces not implementations
- Understanding some frequently used design patterns in the context of the classes developed earlier
- Creational patterns including Abstract factory, Factory method and Singleton
- Structural patterns including Observer and Command
- Behavioural patterns including Strategy, Decorator, Adapter and Facade
|