Implementation Model

Implementation Model Important Concepts Integration

Implementation Model
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.

Purposes
To define the organization of the code in terms of implementation subsystems 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

Implementation Model
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
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
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.

Implement Components
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.

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.

Important Concepts

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.

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

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.

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

Build
Builds help uncover integration problems as soon as they are introduced. They represent ongoing attempts to demonstrate the functionality developed to date. In an iterative development, multiple Builds are produced throughout the lifecycle. One organization used to have an iteration Build that represented executable builds produced at the end of each iteration. Configuration Management is critical in such situations. Therefore, each Build is placed under configuration control in case there is a need to roll back to an earlier version when added functionality causes breakages or when there is otherwise compromised build integrity. Numerous Builds occur during iterative software development. Each Build provides early review points and helps to uncover integration problems as soon as they are introduced.

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

Component - RUP
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 Replaceability (RUP)

Source-File Replaceability: This characteristic makes it easier for component source code to be versioncontrolled, 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/