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. 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
of component systems. We show how to use the UML notation most effectively both to discuss
designs with colleagues, and in documents.
Duration: 5 days
- learn a proven process for building a model-based architecture
- use UML and patterns as a language to communicate about architecture and design
- practice proven techniques in architecting agile systems
- know the major tasks required to develop enterprise components
- understand how to leverage design reuse, as well as the reuse of core components
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, or Eiffel) is an advantage.
Model-based architecture overview
The model-based approach to developing enterprise components
and integrating systems, has become the de facto standard.
- 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
This section introduces the relevant parts of UML.
- static models
- objects, types, attributes, snapshots
- 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
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)
This section covers the key design stages of assigning responsibilities and collaborations,
and decoupling 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)
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
- recursive composite
- state delegation
- interface decoupling
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)
Partial models (views) as reusable artefacts.
- generalization of two example static models
- collaborations: generic designs for interactions
- synthesis of collaborations)
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
- pluggable code and connector protocols
- component kits, and building tools
- component architecture
- common models
- common couplings
- wrapping existing assets
- product vs component building)
- re-engineering existing systems
- business process and existing asset analysis
- wrapping Vs re-engineering
- low-risk re-engineering path)
There is no one process that fits all development requirements.
Instead, we will look at a basic set of process patterns — that is,
patterns that help you plan a component-based development project.
This section reviews the tasks and deliverables involved in a typical project to
develop a model-based component architecture.
- the main tasks and artefacts
- business/conceptual modelling
- specification/requirements modelling
- design and implementation
- integrate and test
- short-cycle development
- spiral model
- phased development
- role of prototyping)
Please note, when taught at your site, this course is customisable;
modules can be adapted, removed, added from other courses, or even created.
Each section of the course 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, and
can also be based on one of your own projects.
This is a pencil-and-paper
course, with group exercises. We can demonstrate a variety of support
tools (such as Enterprise Architect). 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; in addition they do not
promote team working in the class. At the detailed design level,
we will use sketch examples in a pseudo-code that can easily be translated
into Java, C#, or VB-.net.
The course is presented by one of our senior consultants, each of whom
has had at least ten years experience in object oriented analysis, design and software
development, and at least three years' experience as a trainer and
consultant in a diverse range of application areas.