professional software developers tutorial
What follows is the detailed programme.
Delegates may attend the full two days, or an individual session of they
wish.
To BOOK your place on these not to be missed Tutorials CLICK
HERE
DAY ONE
[Intermediate to Advanced]
4 July • Cape Town
9 July •
Johannesburg
System Design: Architectures and Archetypes
The challenges of developing high performance, high reliability, and high quality software systems are too much for ad hoc and informal engineering techniques that might have worked in the past on less demanding systems. New techniques for managing these growing complexities are required to meet today's time-to-market, productivity and quality demands.
This tutorial shows you how to:
engineer the system-wide design to meet performance constraints;
• identify the characteristics
of the problem that determine the system design;
• model the system-wide
design--the software architecture;
• build archetypes that
generate efficient code.
This approach produces a number of beneficial results:
• time-to-market: open
code generation reduces project schedules.
• productivity: reuse
is built in to the software architecture;
• error reduction: archetypes
limit coding errors
The tutorial includes a number of pencil and paper exercises that illustrate the concepts.
DAY TWO
5 July • Cape Town
10 July •
Johannesburg
8:30 • Extreme Modeling
Extreme Programming (XP) is a process that focuses on the critical tasks we do to build the final product: the code. It is very controversial: some love it, others view it as a excuse for hacking. In these days of executable models, the products are the models that describe the problem and the system design. This class covers the principles of XP and the Agile Alliance and and shows how they apply to modeling, as opposed to programming, systems:
• Business People on
Site (a.k.a. "The Planning Game")
• Technical Experts on
Site
• Face-to-Face Communication
• Trust Motivated, Self-Organizing
Teams
• Collective Ownership
and Coding standards
• Sustainable Development
• Harness Change
• Metaphors and Simple
Designs
• Technical Excellence
and Refactoring
• Testing
• Continuous Integration
with Frequent Releases
• Estimate to Improve
• Reflect and Tune (the
process)
The presentation focusses on when--and when not--to apply these techniques, and how to bring them to your project.
10:00 • TEA
10:30 • Coping with Changing Requirements
Changing requirements are a fact of life on any project. But the impact of a requirements change can vary significantly depending on how you organize the analysis and design of the system.
This class focuses on techniques for organizing the analysis and design
so that it responds well to requirements change. We show how to find the
invariants, model them and then express the variants in data.
These techniques will reduce the size of the requirements documents,
as well as the design and code. In addition, the class demonstrates how
to:
• understand the size
and true impact of scope changes,
• maximize the value of
your existing analysis and design work, and
• how to manage the effect
of requirements changes on the team.
12:00 • LUNCH
13:00 • The Case for Using Use Cases
Systems respond to a large number of external signals that cause the system to carry out some desired activity depending on the system's state. Each pairing of external signal and desired response represents a user's requirement on the system, a use case. Use cases, then, are a valuable tool for requirements gathering and analysis. Use cases, however, can be positively dangerous if they are used literally to define the software structure.
This class will tell you when to use cases, when to avoid them, and how
to make best use of them. The class also shows how to:
• use them for requirements
gathering;
• use them carefully for
analysis and design;
• denote use cases using
UML;
• model consequent behavior
from use cases
• manage large numbers
of use cases
14:30 • TEA
15:00 • Modeling Complex Behaviour Simply
Complex dynamic behavior doesn't have to mean complex models. This class
describes how to use the Unified Modeling Language (UML) to model complex
dynamic behavior simply.
We discuss:
• the expressive power
of a modeling language;
• compactness of representation
in a modeling language;
• complexity reduction,
through a variety of techniques;
• how to achieve model
comparability, and why it is important;
• how to achieve consistent
levels of granularity in the model, and why.
Analysts and designers using these techniques can communicate more effectively with application experts, avoid unnecessary arguments with colleagues; improve productivity and reduce time to market.
16:30 • DRINKS