|
1.
Object oriented programming[B]
Introducing the principles of OO design
- aims of OO design
- OO designs are based on the 'real' world
- what's an object?
- distribution of responsibilities
- objects, classes, messages and methods
- decoupling for flexible software
- interfaces and the 'implements' relation
- types and object specifications
- class extension
2.
OO analysis and design
Aims and overview of process
- layering design decisions: abstraction
- exposing gaps and inconsistencies: precision
- traceable designs: continuity
- clear, ready communication: a language for design
- a vanilla process: development from scratch (brief overview)
- business modelling: concepts and tasks
- system requirements models
- responsibilities and collaborations
- persistence, GUI, distribution
- coding in an OO language
- component-based design (brief overview)
- robust, flexible software
- components and interfaces
- components kits and architecture
- component and reuse culture
- patterns (brief overview)
3.
Business modelling and UML basics
This section covers techniques of identifying business concepts and tasks, and introduces relevant parts of UML along the way.
- 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 model
- architecture of business process
- context for software requirements
- basis for component interface definition
- documentation style
4.
Requirements modelling
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
5.
Basic design
The key principle of OO design is assigning responsibilities and designing collaborations.
- separating core from GUI, persistence, and other layers
- selection of control objects
- designing system operations with messages
- decoupling, extensibility, reusability
- CRC 'cards'
- dependencies and visibilities
- the class dictionary
- translation to code [Java, C++, or Smalltalk examples]
|
6.
Basic design patterns [D]
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
7.
Domain coupling [D]
The linkage of the 'core(s)' to presentation, persistence, and other layers.
- GUIs
- reification of use-cases in UI objects
- persistence and proxies
- building atop object and relational DBs
- networks and layering
8.
Development: fundamental tasks
This section reviews the tasks and deliverables involved in a typical object-oriented 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
9.
Standard design patterns [D] [A]
More patterns, based on texts by Gamma
et al, Coplien, Pree, and the PLoP
workshops.
10.
Frameworks: generic models [A]
Partial models (views) as reusable artefacts.
- generalization of two example static models
- collaborations: generic designs for interactions [OORAM]
- roles
- synthesis of collaborations
11.
Reuse and Component-based development
[S]
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, plans, ...
12.
Components - the technology [A]
- pluggable code and connector protocols
- component kits, Beans; building tools
- component architecture
- common models
- common couplings
- wrapping existing assets
- product Vs component building
13.
Distributed systems [A] [see also
"Components"]
- architectures
- CORBA, COM, J2EE
- 3 and n-tier
- defining interfaces in UML
- distributed system building tools
- patterns for distributed systems
14.
Re-engineering existing systems
[A]
- business process and existing asset analysis
- wrapping Vs re-engineering
- low-risk re-engineering path
|
