UML and Patterns for Service Oriented Architectures
Vocational qualification
Inhouse
Description
-
Type
Vocational qualification
-
Methodology
Inhouse
-
Duration
5 Days
Suitable for: The course is aimed at. analysts and designers trying to capture requirements and designs at a high level independently of implementation detail. managers and architects who want to get an appreciation of the strategic issues involved in migrating to an object-oriented development lifecycle and who wish to maximise the benefits of such a migration. This course does not assume any particular prerequisites other than a familiarity with graphical user.
Reviews
Course programme
The objectives of the course are to:
- provide a sound knowledge and understanding of UML, as a common language for talking about requirements, designs, services, and components
- provide insights and an appreciation of the issues and choices involved in discovering and documenting services and components to support services making up an SOA business solution
- provide a thorough coverage of the issues, strategies and options underlying component based development
- give the attendee sufficient competence in object-oriented analysis and design (OOAD) so as to be able to tackle a complete project
- provide an understanding of the key tasks and activities appropriate to developing OO models, and then implementing software from those models.
The class exercises can be done as either pencil and paper exercises, or, if required, the various diagrams can be input via a suitable CASE tool such as Enterprise Architect. However, FTT does not recommend using tools for the exercises, as the details of driving them distracts from the main issues of the language and techniques; and they do not promote team working in the class.
The courses are presented by consultants with, typically, over 10 years of experience of consultancy and training in applying OOAD techniques.
The course can be tailored to a customer's individual requirements; for example, at the level of code detail examples can be given in Java, C++ or C#
Course Benefits
What is UML? UML is a notation used for capturing models that describe things in the real world and things in software. It is mainly pictorial and is easy to learn. UML is a very rich notation and some parts are more applicable to common every-day use than others. This course concentrates on the commonly used notation (i.e. on that 50% of UML that deals with the 90% of the usualy modeling requirements), but does overview the remaining notations.
The emphasis in the examples and exercises is to develop the ability to use UML expressively to capture business processes, specify software, and describe system architectures at both a high level and a low level.
Topics covered include
- using UML as an abstraction and modeling tool to aid problem understanding
- building structured models and mapping from one model to another e.g.
- transforming a model of some business domain into a model of the system that provides the corresponding business services
- using UML to explore system architecture and design issues and alternatives
- expressing service oriented architectures and designs in UML
The most difficult aspects of the SOA approach are the discovery of the appropriate services and the packaging of these services into useful reusable components
Object oriented programming languages, if properly used, considerably help in the construction of flexible and extensible components. However, coming up with desirable components requires good analysis and design, ultimately, down to the level of the selection and specification of the underlying classes and the partition of the various tasks between these classes. Often various tradeoffs need to be made and it is important to be able to describe and communicate these effectively in order to decide between various alternatives.
Course Contents
An introduction to UML and SOA How component technology came about:
- Component Based Development
- Service Oriented Architecture and their need for components
- Documenting what happens to things
- Documenting when things happen
- The importance of readable documents
- UML notation review
- Techniques - how to construct a model
- Roles, actions, and objects: who's involved, what are their goals?
- Identifying services - stories: how do they achieve their goals?
- Snapshots and filmstrips: seeing the changes made by use cases
- Specifying the use cases
- Refining the use cases: zooming in and out
- State machines: the life history of processes and objects
- Relating the different views
- Packaging the model
- Application architecture
- Finding components
- Identifying packages
- Packaging the business entities
- Packaging the business processes
- Decoupling packages
- What's in a package
- Business rules
- The need for business rules
- Identifying business rules
- Designing collaborations - a time-line approach
- Designing collaborations - collaborating objects
- Coordinating components on the ESB
- Coordinators as an OO concept
- Using coordinators
- Refinement of user interface designs
- Designing the presentation tier
- Specifying the information
- Forms
- Statecharts and their use in interface design and specification
- The evolution of middleware
- Integrating systems
- ESB features
- Component collaborations revisited
- Patterns for design
- Coupling and dependencies
- Designing the presentation tier
- Components in the presentation layers
- Interface layer
- The concept of a pattern
- How patterns came to be
- Pattern languages
- Resources
- Basic patterns
- Commonly used Gang of Four patterns
- Interfaces
- Factories
- The observer pattern
- Model, View,Controller
- Composite
- State
- The need for a development process
- Problems with some software development processes
- Strategies for improving the development process
- Iterative development
- Extreme programming
- The importance of clear modeling
- Business (conceptual) modelling
- System (requirements) modelling
- Application (architectural) modelling
- Design modelling
- Implementation
- Architecture & patterns
- Structured walkthroughs
- Simulation of the models and designs
- Using CASE tools to generate code from UML diagrams and models
UML and Patterns for Service Oriented Architectures