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

  Catalysis™ - enterprise development process - syllabus for 5 day course

   
    


objectives
- learn a proven process for creating enterprise components and component architectures
- use UML and OCL, as a common language for talking about requirements, designs, and component interfaces
- practice the main principles of architecting component systems with Catalysis™
- know the major tasks required to develop component models, frameworks, and software
- understand how to leverage reuse and adaptability from component-based development

overview
This course is aimed at the software developer or architect who wants to take a model-based approach to developing enterprise components.  The purpose could be to integrate an enterprise or develop kits of components to develop families of applications.  Catalysis™ is a software development process co-authored by TriReme's Dr Alan Cameron Wills.  Some of these Catalysis™ techniques for component development, are included in UML 1.3. 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 the architecting component systems. We show how to use the UML notation most effectively both to discuss designs with colleagues, and in documents.

The course is suitable for analysts and designers wishing to develop skills in modelling component architectures in UML; and managers and architects wishing to learn a development process focused around enterprise components.  Some knowledge of an OO language (such as C++, Java, Smalltalk, Eiffel) is an advantage.  It
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.  The course is presented by one of our senior consultants, each of whom has at least ten years' experience in software development, and at least three years' experience as a trainer and consultant in a diverse range of application areas.

content

1. Catalysisoverview
A model-based approach to developing enterprise components.
- business modelling: concepts and tasks
- system requirements models
- responsibilities and collaborations
- persistence, GUI, distribution
- component-based design overview
- components and interfaces
- components kits and architecture
- component and reuse culture
- patterns in the process

2. UML
This section introduces those parts of UML relevant to Catalysis™.
- static models
- objects, types, attributes, snapshots
- subtypes
- dynamics
- use-cases and tasks
- event charts
- state charts
- building a business model
- finding use-cases
- connecting use-case and class views
- the dictionary
- UML notation review
- uses of business models
- architecture of business process
- context for software requirements
- basis for component interface definition
- documentation style

3. Requirements and component specification
This section deals with the specification of requirements of a software component, application, or complete system. More modelling patterns and techniques are investigated.
- system context models
- high-level operation specs
- state charts for system models
- meaning of 'model'
- how to start abstract and get more detailed
- event charts: horizontal and vertical expansion
- elaborating models
- relating the levels of detail
- building a system spec
- system context
- defining system use-case goals
- modelling patterns

4. Component design
This section covers the key design stages: assign responsibilities and collaborations, decouple roles and components.
- separating core from GUI, persistence, and other layers
- selection of control objects
- designing system operations with messages
- decoupling, extensibility, reusability
- dependencies and visibilities
- the class dictionary
- translation to code

5. Design patterns
In this section, the usefulness of design patterns as a way of thinking about and describing designs is investigated. Several patterns are discussed, and then a problem is presented which participants model and then sketch a solution for, using the patterns.
- Two-way Link
- Observer
- Recursive Composite
- State Delegation
- Interface Decoupling

6. Domain coupling
The linkage of the 'core(s)' to presentation, persistence, and other layers.
- GUI
- MVC and reification of use-cases in UI objects
- persistence: proxy and building atop object and relational DBs
- networks: layering

7. Frameworks
Partial models (views) as reusable artefacts.
- generalization of two example static models
- collaborations: generic designs for interactions
- roles
- synthesis of collaborations

8. Reuse and adaptability
Reuse does not come automatically, and requires not only appropriate technology, but also management and motivation at the corporate level.
- management and economics of reuse
- component repositories
- what's in the repository
- components, frameworks, patterns, and plans

9. Component technology
- pluggable code and connector protocols
- component kits and building tools
- component architecture
- common models
- common couplings
- wrapping existing assets
- product Vs component building

10. Enterprise components
- architectures
- J2EE, CORBA, DCOM
- 3 and n-tier
- EJBs
- defining interfaces in UML
- distributed system building tools
- patterns for distributed systems

11. Re-engineering existing systems
- business process and existing asset analysis
- wrapping Vs re-engineering
- low-risk re-engineering path

12. Process patterns
There is no one process that fits all development requirements. Instead, we will look at a basic set of process patterns - patterns that help you plan a component-based development project.
- process patterns - introduction
- project-level patterns: green field, re-engineering, short-cycle development, small project, large project, critical systems, systems integration, and component development
- strategic patterns: technology migration, reuse, re-architecture

13. Catalysis
process review
This section reviews the tasks and deliverables involved in a typical Catalysis™ development project.
- the main tasks and artefacts
- business/conceptual modelling
- specification/requirements modelling
- architecture
- design and implementation
- integration and test
- short-cycle development
- spiral model
- phased development
- role of prototyping

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

timings
Day 1
1. Catalysis™ overview
2. UML
3. Requirements and component specification
Day 2
4. Component design
5. Design patterns
6. Domain coupling
Day 3
7. Frameworks
8. Reuse and adaptability
9. Component technology
10. Enterprise components
Day 4
11. Re-engineering existing systems
12. Process patterns
13. Catalysis™ process review

Day 5
Workshop to put Catalysis™ theory into practice on a realistic case study.

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


© TriReme International Limited 2001-2006. All rights reserved.

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