Implementation diagrams

Component Diagram Deployment diagram

Implementation Diagrams
Shows the implementation phase of systems development such as the source code structure and the run-time implementation structure Two types
Component diagrams
Shows the structure of the code itself

Deployment diagrams
Shows the structure of the run time system

Component Diagram
Model the physical components (such as source code, executable program, user interface) in a design

Graph of the designs components connected by dependency relationships

Component is represented by the boxed figure Dependency is shown as a dashed arrow

Component Diagram
Component A

Component B

Dependency

Component Diagram
A component is a physical module of code. Components can include both source code libraries and runtime files. For example, if you are using C++, each of your .CPP and .EXE file you create after the code is compiled is also a component.

Component Diagram
Once the components are created, they are added to a Component diagram and relationships are drawn between them. The only type of relationship between components is dependency

Kinds of Components:
Source code (ex: a file containing the code of a class) Binary object code (Ex: a class library) An executable application (Ex: a client or server in a client-server application)

Component Diagram
UML diagram that displays the components in the system and the dependencies between them. Developers will know which code libraries exists and what the relationships are between them The component dependencies will let those who are responsible for compiling know in which order the components need to be compiled.

Adding Component Dependencies

the only type of relationship that exists between components suggests that one component depends on another drawn as a dashed arrow between the components
Component A

Component B

 In this example, Component A depends upon Component B. In other words, there is some class in A that depends on some class in B These dependencies have compilation implications. In this example, because A depends on B, A cannot be compiled until B has been compiled. Someone reading this diagram will know that B should be compiled first, followed by A.

Deployment Diagrams
Shows the configuration of run-time processing elements and the software components, processes and objects that live in them Graph of nodes connected by communication association. Nodes may contain component instances Components may contain objects Components are connected to other components by dashed-arrow dependencies through interfaces

Deployment Diagram
The deployment diagram shows: The physical communication links between hardware items (machines and other resources such as printers) The relationships between physical machines and processes: what runs where

Deployment Diagram
Physical systems means nodes with association between them A node may be processor capable of running software components!

Deployment Diagram without Software

shillay:Workstation <<LAN>>

craro:PC

This diagram represents deployment diagram without a software

Deployment Diagram
When we are adding the software components ,we are presenting how the system is to operate at runtime Example: A particular running instance of an executable application

Deployment Diagram with a software

shillay:Workstation
OXO:GameEngine

craro:PC <<LAN>>

P2:PlayerInterface

P1:PlayerInterface

Stop