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
Implementation Model
• 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
Implementation Model
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.
Implementation Model
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
Implementation Model
Implementation Model
Workers involved in the Implementation Model
So…
• 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
The Implementer is responsible for the following:
• 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
Implement Components
The Implementer is responsible for the following:
• 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…).
Implement Components
The Implementer is responsible for the following:
• 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.
Implement Components
So…
So…
So…
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
So…
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!
Finally… don’t forget the Traceability!
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