Implementation Model

1. ImplementationModel

2. Sources
• Ivar Jacobson, Grady Booch, James Rumbaugh. The
Unified Software Development Process (Object
TechnologySeries)-1998.
• Ahmad K. Shuja, Jochen Krebs. IBM Rational Unified
Process Reference and Certification Guide—Solution
Designer.IBMPress,2008.
• McConnell., Steve. Code Complete Second Edition - A
practical handbook of software construction. Microsoft
Press.2009
• Sommerville, Ian. Software Engineering Ninth Edition.
Pearson,2011.

3. • ImplementationModel
• ImportantConcepts
• Integration

4. Somewordsenvolved
•Implementation
•Construction?
•Coding?
Codingimply themechanical translationof a preexistingdesignintoacomputerlanguage;
Implementation (SW construction)is not at all
mechanical andinvolves substantial creativity
andjudgment.
Steve McConnell
lead for the Construction
Knowledge Area of the Software
Engineering Body of Knowledge
(SWEBOK) project.

5. Implementationisvital
Implementation is the central activity in
software development.Requirements and
architecture are done before construction so that
you can do construction effectively. System
testing(inthestrictsenseofindependenttesting)
is done after construction to verify that
construction has been done correctly.
Construction is at the center of the software-
developmentprocess.
Steve McConnell

6. Implementationisvital
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

7. ImplementationModel
• The Implementation model describeshow
design model’s elements are implemented
intermsofcomponents.
• It also describeshow components are
organized according to structuration and
modularization approaches available in the
environmentolanguage.
• Itimpliesdependence

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

9. More in deep…
The Implementation explains how todevelop,
organize, unit test, and integrate the
components as they are incrementally
developed in every iteration. Testing during
implementation is limited tounit testing.Other
tests,suchasthesystemtestandtheintegration
test,arecarriedoutwithintheTest.

10. More in deep…
Sommervilleintroduces 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 use
as 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.

11. Aboutreuse
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

12. •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,
executableprograms,andothers)
•Totestthedevelopedcomponentsasunits
•To integrate the results produced by individual
implementers(orteams)intoanexecutablesystem
Purposes

13. •Verifying that the groundwork has been laid so that construction
can proceed successfully
•Determining how your code willbe tested
•Designingand writingclassesand routines
•Creating and naming variables and named constants
•Selectingcontrol structures and organizing blocksof statements
•Unittesting, integration testing, and debugging your own code
•Reviewing other team members' low-level designs and code and
havingthem review yours
•Polishingcode by carefully formatting and commenting it
•Integrating software components that were created separately
•Tuning code to make itfaster and usefewer resources
Specifictasksinvolved
Steve McConnell

14. • TheImplementationModelisacollectionofcomponents
andtheimplementationsubsystemsthatcontainthem.
•Thetermmodelhere is not meant to connote diagrams
and other more abstract representations. Instead, an
Implementation Model consists of Implementation
Elements, Implementation Subsystems, and elements
createdtosupportdevelopertesting.
ImplementationModel

15. Workersinvolvedin theImplementationModel
class Modelo de implementación
Architecture
Description
Implementation model
Deployment model
Software architect
«responsible of»
«responsible of»
«responsible»

16. • The Software Architect is responsible for structuring the
ImplementationModel.
• StructuringtheImplementationModelinvolvesestablishing
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 totreat test assets,updatingtheimplementationview,
andevaluatingtheImplementationModel
ImplementationModel

17. ImplementationModel

18. Workersinvolvedin theImplementationModel
class Modelo de implementación
Integrato
r
System
Integration
Component Enginee
r
Component
Subsystem implementation
«responsible of»
«responsible of»
«responsible of»

19. So…

20. •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
.
ImplementationModel considerate!!

21. TheImplementerisresponsibleforthefollowing:
•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
ImplementComponents

22. TheImplementerisresponsibleforthefollowing:
•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
evaluatingtheresults
ImplementComponents

23. TheImplementerisresponsibleforthefollowing:
•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
automatedtesttool(UnitFramework,TestNG…).
ImplementComponents

24. TheImplementerisresponsibleforthefollowing: •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
.
ImplementComponents

25. So…

26. So…

27. So…

28. 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 thatcombines separate
software components to produce a software
system.
ImportantConcepts

29. Integration is done at several stages and levels
duringtheimplementation.
-Integratingtheworkofateamworkinginthesame
implementation subsystem before releasing the
subsystemtosystemintegrators
-Integratingsubsystemsintoacompletesystem.
Integration

30. Incrementalintegrationmeansthatcodeiswritten
andtestedinsmallpiecesandthencombinedinto
a working whole by adding one piece at a time.
Thebenefitsincludeeasyidentificationoffaults,
fulltestingofcomponents,andearlyfeedback
ontheexecutionofthesystem.
Integration

31. So…

32. ImportantConcepts
Prototypes Prototypes are used to check business viability, to
demonstrate key technology, to obtain project
commitment or funding, to further understand
requirements,andtocheckusability

33. ImportantConcepts
RuntimeObservationand 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
systembehaviorviastatisticalinference.

34. ImportantConcepts
RuntimeObservationand 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,automatedtoolsupportisakeyfactor
inmakingthispracticefeasible.

35. ABuild isan 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 theBuild is
reviewable and objectively demonstrates progress toward
completion. The Build is examined at the review points that the
lifecycleprovides.
Build

36. 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.

37. IntegrationBuildPlan
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
whenintegratingthesystem,anddefinehowthey
aretobeassessed.The Implementer uses this
artifacttoplantheorderinwhichtoimplement
designelementsandwhatandwhentodeliver
tosystemintegration.

38. IntegrationBuildPlan
- Integrator leads the planning and execution of
implementation element integration to produce
builds.
- The Integrator uses the integration build plan as a
planningtool

39. DeveloperTest
The purpose of the Developer Test is to provide the
implementation of a subset of required tests in an efficient
andeffectivemanner.
Most of the Developer Tests are created in the same
timeframes as the software components that need to be
tested.

40. Component-UML
A modular part of a system that encapsulates its contents
and whose manifestation is replaceable within its
environment. Acomponent 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
staticaswellasdynamicsemantics).

41. 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
significantDesignClassesand DesignPackages.
• implementation component - a significant encapsulated part of
the implementation, generally code that implements a design
component
Component-RUP

42. ComponentReplaceability(RUP)
• Source-File Replaceability:This characteristic makes it
easier for component source code to be version-
controlled,baselined,andre-used
• DeploymentReplaceability:thereisonefileoronesetof
files that deploy the component and no other
component
• Run-Time Replaceability:This enables software to be
upgradedwithoutlossofavailability.
• LocationTransparency

43. More aboutComponents
• http://www.agilemodeling.com/artifacts/componentDiagram
.htm
• http://www.ibm.com/developerworks/rational/library/dec04/
bell/

44. Finally… don’tforgettheTraceability!

45. Finally… don’tforgettheTraceability!

46. Finally… don’tforgettheTraceability!

47. ImplementationEnviromentFeatures(Sommerville)
A software development platform should provide a range oftools
to support software engineering processes.These may include:
1. An integrated compiler and syntax-directed editing system that
allowsyou to create, edit, and compilecode.
2.Alanguage debugging system.
3. Graphical editing tools,suchas tools to edit UMLmodels.
4. Testing tools, such as JUnit that can automatically run a set of
tests on a new versionof a program.
5. Project support tools that help you organize the code for
different development projects.

48. Be careful
•Implementationhavepatternsalso….
•SeeClean Codeof Robert C. Martin, and
ImplementationPatternsofKentBeck

49. Be careful (http://www.agilemodeling.com/artifacts/componentDiagram.htm)
UML1.0
UML2.0

50. Thanks for your attention [email protected]