Implementation

Yaodong Bi

Introduction to Implementation

Purposes of Implementation– Plan the system integrations required in each

iteration– Distribute the system by mapping executable

components onto nodes in the deployment model– Implement the design classes and subsystems

found during design as file components– Unit test the components, then integrate then by

compiling them linking them together into one or more executables.

Artifacts of Implement. - Overview

Implementation model Components Implementation subsystems Interfaces Architecture description Integration build plan

Artifacts – Implementation Model

Implementation model– Describe how elements in the design model are

implemented in terms of components such as source code files, executables, and so on.

– Describe how the components are organized according to the structuring and modularization mechanisms available in the implementation environment and programming languages

Artifacts – Components

Components– A component is the physical packaging of model

elements, such as design classes in the design model

– Standard stereotypes of components: <<executable>> is a program that may run on a node <<file>> is a file containing source code or data <<library>> is a static or dynamic library <<table>> is a database table <<document>> is a document

Artifacts – Components

Components– Components have trace relationships to the model

element they implement such as design classes– It is common for a component to implement several

elements. (p. 270, Fig 10.4)– Components provide the same interfaces as the

model elements they implement (p 271, Fig 10.5)– There can be compilation dependencies between

components (p. 271, Fig 10.6)

Artifacts – Components

Stubs– A stub is a component with a skeletal or special-

purpose implementation that can be used to develop and test other components

– Stubs can be used to minimize the number of new components required in each new (intermediate) version of the system.

Artifacts – Implement. Subsystems

Implementation subsystems– Provide a means of organizing the artifacts of the

implementation model into more manageable pieces

– A subsystem may consists of components, interfaces, and other subsystems

– An implementation subsystem is manifested by an actual “packaging mechanism” in the implementation environment such as a package in Java, a project in VB, etc.

Artifacts – Implement. Subsystems

– An implementation system should be traced one-to-one to a corresponding design subsystem

– The implementation subsystem should define analog dependencies toward other implementation subsystems

– The implementation subsystem should provide the same interface

– The implementation subsystem should define which contained components provide each of the interfaces (p273 Fig 10.8)

Artifacts – Interfaces

Interfaces– Specify the operations implemented by components

and implementation subsystems– A component that realizes an interface must

implement all operations defined by the interface– An implementation subsystem that provides an

interface must also contain components that provide the interface (p.275, Fig 10.10)

Artifacts – Architecture (Implem.)

Architecture description (view of the implementation model)– Subsystems, their interfaces, and dependencies

between them. They have a one-to-one mapping to design subsystems

– Key components mapping to significant design classes, executable components, general components

Artifacts – Integration Build Plan

Integration build plan– Build: an executable version of the system– Built incrementally in manageable steps– Integration build plan: the sequence of builds in an

iteration. It describes: The functionality to be implemented, as a list of use-cases Which parts of the implementation model are affected by

the build, as a list of subsystems and components

Activities of Implement. - Overview

Architectural Implementation– Outline the implementation model and its

architecture.

Integrate system– Create an integration plan and integrate each build

Implement subsystems– Ensure each subsystem fulfill its role in each build

Activities of Implement. - Overview

Implement classes– Implement each design class in a file component

Perform unit test– Test the implemented components as individual

units

Architectural Implementation

Identify and implement architecturally significant components, such as executable components – Consider each active class as an executable

component (p. 282, Fig 10.18) Mapping components to nodes in the

deployment model– Map each component to the node its corresponding

design active class assigned to. (p. 282, Fig. 10.19)

Integrate System

Create an integration build plan describing each build and its requirements

– Each build should add functionality to the previous build by implementing complete use-cases

– Each build should include too many new or refined component. Stubs may be used for components

Integrate each build before it is subject to integration test.

– Collect the right versions of subsystems and components, compiling them, and linking them into a build

Implement Subsystems

Maintain the subsystem contents– A subsystem should fulfill its purpose for the current

build by components– Each class (and subsystem) required for the current

build should be implemented by components (and implementation subsystem) of the implementation subsystem (p. 286, Fig 10.22)

– Each interface required by the build must be implemented by components (p. 287. Fig 10.23, Fig 10.24)

Implement Classes

Outline the file components for source code– The source code for each class resides in a file component– The chosen file components should support the compilation,

installation, and maintenance of the system Generating code from a design class

– Many details of a design class are described during design– Code for association and aggregation depends the language

Associations reference attribute in the referring object The name of the attribute is the role name of the association at

the opposite end Multiplicity determines the type of the reference: a simple pointer

or a collection of pointers

Implement Classes

Implementing operations– Methods: implementations of an operation– Methods may be described in natural language in design – Choose a suitable algorithm and data structures for each

operation– The states of the design class may impact on the

implementation

Making the component provide the right interface– The resulting component should provide the same interfaces

as the design class(es) it implements

Perform Unit Test

Specification testing or black-box testing– Verify the unit’s externally observable behavior– The range of inputs, outputs, and states are divided

into equivalence classes– An equivalence class: a set of inputs, outputs, or

states for which an object is supposed to behavior similarly

– Test components for each combination of the equivalence classes. (p290, example)

Perform Unit Test

Structure testing or white-box testing– Verify the unit’s internal implementation– Every statement is executed at least once.– Test the most interesting paths through the code

Most commonly followed paths Most critical paths The least-known paths High risk paths. (p292, Fig 10.27)

Summary of Implementation

Implement subsystems including their contents, interfaces, and their dependencies

Implement components: file and executable components, and their dependencies on each other

Unit test components Define the architectural view of the implementation

model. Implementation model is the primary input to

subsequent testing activities