testimonials
contact us
about us
partners
site map
courses
clients
home
news
links

 

SOA & UML course in Stockport
(near Manchester)

22nd September 2008


Web Usability Patterns Site


Web Usability Products & Services

A comprehensive tutorial on UML





      
your requirementscustom solutionsexpert helpwhitepapers

 UML and Service Oriented Architecture syllabus for onsite courses

   
    

Tailored to your requirements

This SOA with UML course is part of a package, including mentoring, aimed at providing a low-risk migration towards UML-based analysis and design for service- and component-based systems. We tailor the content of the course to suit your needs.

Objectives

  • acquire a knowledge of UML, a common language for talking about requirements, designs, services, and components;

  • understand the issues and options in discovering and documenting services and components to support those services;

  • understand the issues and options of component based development;

  • gain enough competence in object-oriented analysis and design (OOAD) to tackle a complete project; and

  • understand what major tasks are appropriate to developing OO models, and developing software from those models.

Course philosophy

UML is a notation that is used for capturing models that describe things in the real world and things in software. The notation is mainly pictorial and is straightforward to learn. However, not all of the UML language is useful in every-day use — about 50% of the notation will cover 90% of its application area. We teach this useful core, and indicate how the remainder of the language can be used. We also concentrates on how the language can be used as a modelling tool rather on what the language is. As with learning a foreign language, just learning the vocabulary and a few simple sentences is not enough, you need to learn both how to speak and use the language. The courses look at how UML can be used as an expressive tool to describe business domains, software specifications, architecture, and both the high and low-level design of the software.

The course concentrates on:

  • abstraction, a tool for problem understanding;

  • how to model using UML;

  • how to transform a model of the domain into a model of the system that provided business services;

  • how to use UML to investigate architectural and design issues; and

  • how to express service oriented architecture and designs in UML.

Overview

The two major thrusts in modern software development today are components and Service Oriented Architecture (SOA). Components provide a powerful tool for building flexible and extensible software systems; service-based architecture provides the means of constructing such systems quickly and flexibly. The major problem in this approach is the discovery of services and packaging the services into useful, reusable components.

Object oriented programming languages provide a powerful tool for building flexible and extensible software components. However, maximum benefits are gained only if the software is appropriately designed. The choice of classes, and the distribution of tasks between the objects, is of crucial importance. Software development is a team effort, and it is equally important that developers have a language for talking about analyses and designs: a language that is less ambiguous than English, but able to deal in requirements and high level design without being cluttered by the fine detail of program code.

This course separates and makes explicit the decisions that make up an OO analysis and design. We show how to use the UML notation most effectively both to discuss designs with colleagues, and in documents. UML is now an industry standard, supported by all the major tools. The course provides especially strong coherence between the different notations used in UML, making it clear when there are inconsistencies or holes in the analysis. This saves a lot of money in the later stages of a project.

The course is suitable for analysts and designers wishing to develop clear precise methods of discussing requirements and designs at a high level, clear of implementation detail; and managers and architects wishing to understand the strategic issues in migrating to, and getting the best out of, an object-oriented development lifecycle. Some knowledge of an OO language (such as C++, Java, Smalltalk, Eiffel) is an advantage.

Each section uses numerous small examples and exercises. Two major examples are followed through the course: one discussed in class as each point is introduced, and one developed by participants in groups. Depending on the background of the participants, the exercises can be chosen from commercial or process control areas. This is a pencil-and-paper course, with group exercises. We can demonstrate a variety of support tools (such as Rose, Select, or Rhapsody). However, we do 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. At the detailed design level, we will use examples in Java, C++, or another language of your choice. The course is presented by one of our senior consultants, each of whom has at least ten years' experience in object oriented software development, and at least three years' experience as a trainer and consultant in a diverse range of application areas.


Content

An introduction to UML and SOA

Why component technology?
Component Based Development
Service Oriented Architecture
What is a software development process?
The background to UML
Resources and references

The basics of modelling

The basic ideas
The fundamental UML modelling tools

UML: the basics

Using UML Types
Use cases and business services
More diagrams and meanings
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 a 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
Composing models: from different viewpoints

Packaging the model

Packaging
Application architecture
Finding components
Identifying packages
Packaging the business entities
Packaging the business processes
Decoupling packages
What’s in a package
Roles and reuse

Business rules

The need for business rules
Identifying business rules

The interface tier

Users of the system (actors) as concepts
Specifying information

Analysis patterns
Modelling patterns
Multiple Inheritance and roles
More modelling patterns — where have I seen that before?

The following topics cover additional analysis patterns; patterns are included according to the course emphasis.

The powerset pattern
The composite pattern
The quantity pattern
The party pattern
Relationships between parties
Observations
Plans and planning

Component architecture — some ideas

Components
Choosing components
Sharing types and associations

An interlude, some UML for design

Designing collaborations — a time-line approach
Designing collaborations — collaborating objects

Coordinating components on the ESB

Coordinators as an OO concept
Using coordinators
Specifying the interfaces
Refinement (optional)

Designing the presentation tier

Specifying the information
Forms

Enterprise Service Bus — the ideas

The evolution of middleware
Integrating systems
ESB features

Component implementation — building the system with objects

Classes, reponsabilities and collaborations
Component collaborations revisited
Patterns for design
Coupling and dependencies

Designing the presentation tier

Components in the presentation layers
Interface layer

The pattern concept

The concept of a pattern
Some background
Pattern languages
Resources
Patterns

Patterns

Basic patterns
Some basic Gang of Four patterns
Two way link
Adding new interfaces
Factories
The observer pattern
Model, View,Controller
Composite
State

A background to the development process

The need for a development process
Problems with process
Some ideas for dealing with the process
Iterative development

A review of the techinical process

Business (conceptual) modelling
System (requirements) modelling
Application (architectural) modelling
Design modelling
Implementation
Architecture & patterns
The whole picture

Conclusion

A quick review of the ideas and concepts

 

Please note, when taught at your site, this course is customizable.  Modules can be adapted, removed, added from other courses, or even created.

To book a public or onsite course, please contact Clive Menhinick on +44 (0)161 225 3240, or email him: clive@trireme.com.  Alternatively, use the booking form.

© TriReme International Limited 2006. All rights reserved.

 
email us  or  tel  UK:  01625 850 839  international:  +44 1625 850 839