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.

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.