implementation model

Implementation Model

Sources

• Ivar Jacobson, Grady Booch, James Rumbaugh. The

Unified Software Development Process (Object

Technology Series)-1998.

• Ahmad K. Shuja, Jochen Krebs. IBM Rational Unified

Process Reference and Certification Guide—Solution

Designer. IBM Press, 2008.

• McConnell., Steve. Code Complete Second Edition - A

practical handbook of software construction. Microsoft

Press. 2009

• Sommerville, Ian. Software Engineering Ninth Edition.

Pearson, 2011.

• Implementation Model

• Important Concepts

• Integration

Before..

Cartoon: NP

Designers and developers don't really

speak the same language.

(From:

http://chetchat.blogspot.fr/2014/08/cartoon-np.html)

Some words envolved

• Implementation

• Construction?

• Coding?

Coding imply the mechanical translation of a

preexisting design into a computer language;

Implementation (SW construction) is not at all

mechanical and involves substantial creativity

and judgment.

Steve McConnell

lead for the Construction

Knowledge Area of the Software

Engineering Body of Knowledge

(SWEBOK) project.

Implementation is vital

Implementation is the central activity in

software development. Requirements and

architecture are done before construction so that

you can do construction effectively. System

testing (in the strict sense of independent testing)

is done after construction to verify that

construction has been done correctly.

Construction is at the center of the software-

development process.

Steve McConnell

Implementation is vital

Construction is the only activity that's guaranteed to be

done. The ideal software project goes through careful

requirements development and architectural design before

construction begins. The ideal project undergoes

comprehensive, statistically controlled system testing after

construction. Imperfect, real-world projects, however, often skip

requirements and design to jump into construction. They drop

testing because they have too many errors to fix and they've

run out of time. But no matter how rushed or poorly planned

a project is, you can't drop construction; it's where the

rubber meets the road. Improving construction is thus a

way of improving any software-development effort, no

matter how abbreviated.

Steve McConnell


• The Implementation model describes how

design model’s elements are implemented

in terms of components.

• It also describes how components are

organized according to structuration and

modularization approaches available in the

environment o language.

• It implies dependence


From: "The Unified Software Development Process (Object Technology Series)“-1998

More in deep…

The Implementation explains how to develop,

organize, unit test, and integrate the

components as they are incrementally

developed in every iteration. Testing during

implementation is limited to unit testing. Other

tests, such as the system test and the integration

test, are carried out within the Test.

More in deep…

Sommerville introduces some aspects of implementation that are particularly

important to software engineering that are often not covered in programming

texts

1. Reuse. Most modern software is constructed by reusing existing components

or systems. When you are developing software, you should make as much useas possible of existing code.

2. Configuration management. During the development process, many

different versions of each software component are created. If you don’t keep

track of these versions in a configuration management system, you are liable to

include the wrong versions of these components in your system.3. Host-target development. Production software does not usually execute on

the same computer as the software development environment. Rather, you

develop it on one computer (the host system) and execute it on a separate

computer (the target system). The host and target systems are sometimes of the

same type but, often they are completely different.

About reuse

Software reuse is possible at a number of different

levels:

1. The abstraction level.

2. The object level

3. The component level

4. The system level

•To define the organization of the code in terms of

implementation subsystems (maybe organized in

layers)

•To implement the design elements in terms of

implementation elements (source files, binaries,

executable programs, and others)

•To test the developed components as units

•To integrate the results produced by individual

implementers (or teams) into an executable system

Purposes

•Verifying that the groundwork has been laid so that construction

can proceed successfully

•Determining how your code will be tested

•Designing and writing classes and routines

•Creating and naming variables and named constants

•Selecting control structures and organizing blocks of statements

•Unit testing, integration testing, and debugging your own code

•Reviewing other team members' low-level designs and code and

having them review yours

•Polishing code by carefully formatting and commenting it

•Integrating software components that were created separately

•Tuning code to make it faster and use fewer resources

Specific tasks involved Steve McConnell

• The Implementation Model is a collection of components

and the implementation subsystems that contain them.

• The term model here is not meant to connote diagrams

and other more abstract representations. Instead, an

Implementation Model consists of Implementation

Elements, Implementation Subsystems, and elements

created to support developer testing.


Workers involved in the Implementation Model

• The Software Architect is responsible for structuring the

Implementation Model.

• Structuring the Implementation Model involves establishing

the Implementation Model structure, adjusting

implementation subsystems, defining imports for each

implementation subsystem, deciding how to treat

executable programs and other derived objects, deciding

how to treat test assets, updating the implementation view,

and evaluating the Implementation Model


Workers involved in the Implementation Model

• Implement design elements— The Implementer implements the

elements in the design model; that is, he writes source code,

adapts existing source code, compiles, and links and performs unit

tests. If he discovers defects in the design, he submits rework

feedback on the design.

• Fix code defects— The Implementer also fixes code defects

identified during the unit tests and performs further unit testing to

ensure that no new defects have emerged and that the change is

verified.

• Evaluate quality— Finally, the Implementer reviews the code to

evaluate quality and compliance with the Programming Guidelines.

Implementation Model considerate!!

The Implementer is responsible for the following:

• Implementing design elements - This involves preparing

for implementation, transforming the design to

implementation, completing the implementation, evaluating

the implementation, and providing feedback to design. In

implementing the design elements, the Implementer

produces an Implementation Element and Implementation

Subsystem

Implement Components


• Analyzing runtime behavior— This is done by

determining the required execution scenario, preparing

implementation components for runtime observation,

preparing the environment for execution, executing the

component and capturing behavioral observations,

reviewing behavioral observations and isolating initial

findings, analyzing findings to understand root causes,

identifying and communicating follow-up activities, and

evaluating the results



• Implementing testability elements and producing the

Testability Element and the Test Stub— This involves

implementing and unit testing drives/stubs and

implementing and unit testing the interface to the

automated test tool (Unit Framework, Test NG…).



• Implementing and producing the Developer Test— This is

achieved by refining the scope and identifying the tests, selecting

the appropriate implementation techniques, implementing the test,

establishing external data sets, verifying the test implementation,

and maintaining traceability relationships.

• Executing developer tests and producing the Test Log— This

requires executing the unit tests, evaluating the execution of tests,

verifying the test results, and recovering from halted tests.


Integration

Large software systems require multiple software

components, some off the shelf and others

custom developed, to be integrated into a whole

system. This is a specialized software

development activity that combines separate

software components to produce a software

system.

Important Concepts

Integration is done at several stages and levels

during the implementation.

-Integrating the work of a team working in the same

implementation subsystem before releasing the

subsystem to system integrators

-Integrating subsystems into a complete system.

Integration

Incremental integration means that code is written

and tested in small pieces and then combined into

a working whole by adding one piece at a time.

The benefits include easy identification of faults,

full testing of components, and early feedback

on the execution of the system.

Integration

Important Concepts

Prototypes

Prototypes are used to check business viability, to

demonstrate key technology, to obtain project

commitment or funding, to further understand

requirements, and to check usability

Important Concepts

Runtime Observation and Analysis

This concept encompasses the observation of the software

during runtime execution and analysis of the captured

annotations where paths are traced through software

components and then aggregated to understand global

system behavior via statistical inference.

Important Concepts

Runtime Observation and Analysis

Because of the potential volume of the low-level

information that can be captured from runtime

behavior, the speed at which that information is

generated, and the subsequent difficulty in

understanding the potentially vast amount of

information, automated tool support is a key factor

in making this practice feasible.

A Build is an operational version of a system or a part of the

system that demonstrates a subset of the capabilities

provided in the final product. The Build constitutes an integral

part of the iterative development lifecycle and provides review

points. Note that in all iterative incremental development

processes, progress is demonstrated via an executable, a

(working) software deliverable rather than just documents or the

like. The lifecycle “provides review points,” but the Build is

reviewable and objectively demonstrates progress toward

completion. The Build is examined at the review points that the

lifecycle provides.

Build

Build

The purpose of a Build, constructed from other elements in

the implementation, is to deliver a testable subset of the

runtime functions and capabilities of the system.

Integration Build Plan

This artifact provides a detailed plan for integration

within an iteration. The purpose of this artifact is

to define the order in which to implement the

components, determine which builds to create

when integrating the system, and define how they

are to be assessed. The Implementer uses this

artifact to plan the order in which to implement

design elements and what and when to deliver

to system integration.

Integration Build Plan

- Integrator leads the planning and execution of

implementation element integration to produce

builds .

- The Integrator uses the integration build plan as a

planning tool

Developer Test

The purpose of the Developer Test is to provide the

implementation of a subset of required tests in an efficient

and effective manner.

Most of the Developer Tests are created in the same

timeframes as the software components that need to be

tested.

Component - UML

A modular part of a system that encapsulates its contents

and whose manifestation is replaceable within its

environment. A component defines its behavior in terms of

provided and required interfaces. As such, a component

serves as a type, whose conformance is defined by these

provided and required interfaces (encompassing both their

static as well as dynamic semantics).

An encapsulated part of a system, ideally a non-trivial, nearly

independent, and replaceable part of a system that fulfills a

clear function in the context of a well-defined architecture. This

includes:

• design component - a significant encapsulated part of the

design, and so includes Design Subsystems and sometimes

significant Design Classes and Design Packages.

• implementation component - a significant encapsulated part of

the implementation, generally code that implements a design

component

Component - RUP

Component Replaceability (RUP)

• Source-File Replaceability: This characteristic makes it

easier for component source code to be version-

controlled, baselined, and re-used

• Deployment Replaceability: there is one file or one set of

files that deploy the component and no other

component

• Run-Time Replaceability: This enables software to be

upgraded without loss of availability.

• Location Transparency

More about Components

• http://www.agilemodeling.com/artifacts/componentDiagram

.htm

• http://www.ibm.com/developerworks/rational/library/dec04/

bell/

Finally… don’t forget the Traceability!

Implementation Enviroment Features (Sommerville)

A software development platform should provide a range of tools

to support software engineering processes. These may include:

1. An integrated compiler and syntax-directed editing system that

allows you to create, edit, and compile code.

2. A language debugging system.

3. Graphical editing tools, such as tools to edit UML models.

4. Testing tools, such as JUnit that can automatically run a set of

tests on a new version of a program.

5. Project support tools that help you organize the code for

different development projects.

Be careful

• Implementation have patterns also….

• See Clean Code of Robert C. Martin, and

Implementation Patterns of Kent Beck

Be careful (http://www.agilemodeling.com/artifacts/componentDiagram.htm)

UML 1.0

UML 2.0

Thanks for your attention

[email protected]

implementation model

Education