Implementation Workflow
Implementation Workflow
Introduction
Introduction
• Implement the design in terms of components
− source code, scripts, binaries, executables, etc. • Flesh out the architecture
• Plan system integrations in each iteration − incremental: small, manageable steps • Distribute system: map components to nodes
− focus on active classes
• Implement design classes and subsystems • Unit test components
• Integrate components (compile and link into one or
more executables) for integration and system tests
• Focus of construction phase
− architecture baseline in elaboration phase; defects
Implementation Focus
Implementation Focus
Core Workflows Phases
Requirements
Analysis
Design
Implementation
Test
Inception Elaboration Construction Transition
Iterations
Artifacts
Artifacts
• Implementation Model − Component − Implementation Subsystem − Interface • Architecture Description− Implementation view of architecture • Integration Build Plan
− Sequence of builds in an iteration − Functionality in each build
• Note: keep design model current via round-trip
engineering
− Design model provides a visualization of
Implementation Workflow
Activities and Workers
Implementation Workflow
Activities and Workers
Architect System Integrator Component Engineer Architectural Implementation Integrate System Implement a Class Implement a Subsystem Perform a Unit Test
Implementation Model
Implementation Model
• Describes how elements of design model are
implemented in terms of components such as source code, executables, etc.
• Describe how components are organized using the
structuring and modularization mechanisms of the implementation environment and programming
languages
− Hierarchy of Implementation (sub)Systems
containing Components and Interfaces
Component
Component
• Physical packaging of model elements • Standard stereotypes
− <<executable>> -- a program that may run on a
node
− <<file>> -- file containing source code or data − <<library>> -- static or dynamic library
− <<table>> -- a database table − <<document>> -- a document
− technology specific (<<ActiveX>>, <<Applet>>,
Component Characteristics
Component Characteristics
• Components trace to the model elements they
implement (hence all the way back to use cases)
• A component usually implements several elements • Components provide the same interfaces as the
model elements they implement
• Compilation dependencies denote which
components are required to compile a specific component
• Implement component stubs to ease compilation,
Trace between implementation and design
Trace between implementation and design
AccountTransfers.java <<file>>
Transfers Transfers
AccountTransfers <<trace>>
Implementation subsystem
Implementation subsystem
• Organize implementation model artifacts into more
manageable pieces
• Manifested by a “packaging mechanism” in implementation
environment
− package in Java
− project in VB, VC++ − directory in C++
− CORBA server in CORBA
− Component View package in Rational Rose • Trace one-to-one with design subsystems
− same dependencies to other subsystems, interfaces − provides same interfaces
§ maps one-to-one with which components or other
implementation subsystems within the subsystem provide the interfaces of the subsystem
Interface
Interface
• As in design, interfaces define the operations
implemented by components and implementation subsystems
• A component that realizes (and thus provides) an
interface must implement all the operations defined by the interface
• A subsystem that realizes (and thus provides) an
interface must also contain components that provide the interface or other subsystems (recursively) that provide the interface
Architecture description
Architecture description
• Architectural view of implementation model • Decomposition of implementation model into
subsystems, their interfaces, and dependencies between them
− redundant with architectural view of design
model due to one-to-one mapping
• Key components
− trace to architecturally significant design
classes
− executable components
− components that are general, central, or
implement generic design mechanisms that many other components depend on
4+1 View of Architecture
and the workflows that define the views
4+1 View of Architecture
and the workflows that define the views
Logical View Functionality Implementation View Software management Process View Performance, scalability, throughput Deployment View System topology, delivery, installation, communication
Use Case View
Understandability Usability Requirements Analysis Design Design Implementation
Integration Build Plan
Integration Build Plan
• Incremental build in small, manageable steps
− limits scope of integration and test problems − “build” is an executable version of system
− should put the build under version control so can roll
back on test failure
• Build plan for each increment
− list of functionality: use cases and/or scenarios − list of implementation subsystems and components • Test each build, including regression tests
• Typically multiple builds per iteration • Benefits
− early executable system reduces risk − start integration tests early
Workers
Workers
• Architect
− Responsible for the integrity of the
implementation model (correct, consistent and readable as a whole)
• Component engineer
− Defines and maintains source code of several file
components
− Maintains integrity of one or more implementation
subsystems
− Typically the designer of the corresponding
subsystems
• System integrator
− Plan build sequence
Details and Guidelines
Details and Guidelines
• Architectural implementation
− Identifying architecturally significant components
§ Identifying executable components and deploying
them to nodes
• Integrate system
− Planning a subsequent build − Integrating a build
• Implement a subsystem
− Maintaining the subsystem contents • Implement a class
− Outlining file components that will contain source code − Generating code from a design class and its relationships − Implementing operations in terms of methods
− Making the component provide the right interfaces • Perform unit tests
− Perform specification testing (black box; external) − Perform structure testing (white box; internal)
Summary
Summary
• Implementation Model
− Implementation (sub)systems and their
dependencies, interfaces and contents
− Components
§ File and executable components § Dependencies
− Components unit tested
− Architecture view of implementation model − Integration Build Plan
§ Each build from implementation is
integration tested and system tested in Test Workflow
