Key Benefits
You will learn how to:
- Express architectural principles
- Capture architectural patterns using UML
- Create structural and behavioral views of the architecture using UML models
- Graphically model components (using UML) to understand/communicate their structure and
behavior
- Design and document components and their interfaces
Capture architectural requirements using Use Cases for
run-time requirements and Test Cases for qualities
Perform architecture analyses and validate the architecture
Use our Action Guides to guide you through each key
architecting activity
Background
Software architecture is
the high-level structure of a software system. Its importance derives from the role it
plays in system development: it is the translation of business strategy into technical
strategy, and is thus the foundation for competitive advantage
it helps address system
complexity, making the system more understandable and more manageable
 The Unified Modeling Language (UML) is the
industry-standard language for specifying, visualizing, constructing, and documenting the
artifacts of software systems. We focus on those
UML models that are useful for capturing and communicating software architecture.
 Action
Guides are short (fit on an index card) and designed to solve a specific
architecting problem (e.g., develop an architectural vision, capture non-functional
requirements or document interfaces). Taken together, they provide a comprehensive
architecting process that uses UML as the modeling language. Used selectively, they
provide a mechanism for teams to tailor their own lightweight architecting method. Used
individually, they produce some key result for the architecting team. (See an example Action Guide)
Class
Overview
This class covers the concepts and concerns central
to software architecture. With that groundwork laid, the majority of the time is focused
on the architecting process. Each architecting activity is motivated with stories. The
concepts, techniques and models for each phase of requirements, structuring and validation
are explained and demonstrated, then practiced in small teams. Action Guides provide handy
references as teams fill out templates or create graphical models using UML.
The workshop addresses such questions as:
- What is a software architecture? (There are multiple definitions out there.)
- How do I use UML to model the system? Which models best capture the structure of the
system? the behavior of the system? and the mapping of software components to the physical
system?
- What have others learned in creating architectures? What works? What does not?
- What should we think about when designing the architecture?
- How should we document the architecture?
- What should we communicate, to whom?
Why
This Class?
This class focuses on the technical core of
architecting, and in particular on modeling software architecture using UML. Our Role
of the Architect and Software
Architecture workshops include the more non-technical aspects of architecting. If you
are a technical contributor on an architecture team, you may prefer the concentration on
the technical aspects of architecting offered in this course. Also, though many UML
classes are available, they do not focus on architecture as we do.
Audience
Senior software developers, architects and managers
of architecture projects.
Instructor's Background
The instructor,
Ruth Malan, has over 15 years experience in software engineering, architecture and
consulting, including 6 years with Hewlett-Packard. Together with Dana Bredemeyer, she
pioneered the internal architecture training and consulting program at HP. She has
provided architecture consulting and training to architects, architecture teams and their
management, and has helped teams develop component architectures. Ruth has published
extensively in the areas of object-oriented development, reuse, and architecture, and is
an author and editor of the book Object-Oriented Development at Work: Fusion in the
Real World. Ruth is currently co-authoring a book on software architecture with Dana
Bredemeyer, for Prentice-Hall. |
Class Outline
This 4-day workshop covers the following
topics:
Introduction to Software Architecture
- What is software architecture?
Central concerns of software architecture
Architecting pitfalls and critical success factors
The architecting process and Software Architecture Action
Guides
The role of UML in architecting
Architectural Requirements
- System context and scope
- Functional (i.e., behavioral) requirements
- Non-functional requirements (i.e., system qualities including run-time qualities such as
performance and reliability, and development-time qualities such as
evolvability/extensibility and reusability)
- Use cases and test cases
Architecture Modeling with UML
Meta-architecture: the
architectural vision, style, principles, key communication and control mechanisms, and
concepts that guide the team of architects in the creation of the architecture.
Architectural patterns: the role of
patterns; documented patterns such as layers and client/server, brokers and bridges; how
to capture patterns
Architectural views: Structural views
that help document and communicate the architecture; Behavioral views that are useful in
thinking through how the components interact to accomplish their assigned responsibilities
and in evaluating the impact of what-if scenarios on the architecture.
Conceptual Architecture: decomposing
the system into subsystems and components; assigning component responsibilities (using
Action Guides with templates and UML models)
Logical Architecture: creating
the architectural blueprint; interface design and specification; component documentation
(using Action Guides with templates and UML models)
Execution Architecture: mapping
components to processes and threads, and to nodes in the physical system to evaluate
distribution options and document decisions (using Action Guides with templates and
UML models)
Key architectural design principles
including abstraction, separation of concerns, postponing decisions, and simplicity,
and related techniques such as interface hiding and encapsulation, as well as system
decomposition principles and good interface design.
- Heuristics for system decomposition
Architecture Validation
- Architecture validation techniques (reviews, assessments, prototypes)
- Impact assessment and SAAM
Venue
You
can hold this workshop at your company site, or wait for the next open
enrollment workshop. If 5 or more people from your company
would like to attend this class, you will find it more cost effective to hold the class at
your company site. Please call us at (812) 335-1653 or email training@bredemeyer.com for pricing and
schedule.
Pricing
The cost for the
4-day class is $2300 per student. We offer a 10% discount for
early registration. Note: We only accept a maximum of 16
participants, so register early to avoid disappointment.
Continental breakfasts, lunches and snacks
will be provided, but workshop participants are responsible for dinners and their own
accommodations.
Cancellation Policy
We will refund the
registration fee less a $100 processing fee if cancellations are made
more than 21 days in advance of the workshop start date.
Cancellations made 21 days or less from the workshop start date are not refundable.
However, student substitutions may be made any time prior to the start of the workshop.
ABOUT BREDEMEYER
CONSULTING|
Bredemeyer Consulting specializes in training and mentoring software architects. We
typically work with architecture teams, providing training and mentoring to accelerate
their creation or migration of an architecture. However, we do offer a limited number of
Software Architecture and related workshops for open enrollment.
|
