# data[].attributes.body
Deployment Diagrams
- A deployment diagram is a diagram that shows the configuration of run time processing nodes and the components that live on them.
- Deployment diagrams are one of the two kinds of diagrams used in modeling the physical aspects of an object-oriented system.
- Used to model the static deployment view of a system (topology of the hardware)
- A deployment diagram is a collection of vertices and arcs.
- Deployment diagrams are important for visualizing, specifying, and documenting embedded, client/server,
and distributed systems and also for managing executable systems through forward and reverse engineering.

# data[].attributes.body
To model a client/server system,
-Identify the nodes that represent your system’s client and server processors
-Highlight those devices that are germane to the behavior of your system.
-Provide visual cues for these processors and devices via stereotyping.
-Model the topology of these nodes in a deployment diagram. Similarly, specify the relationship between the components in your system’s implementation view and the nodes.

# data[].attributes.body
The model an embedded system,
-Identify the devices and nodes that are unique to your system.
-Provide visual cues, especially for unusual devices, by using the UML´s extensibility mechanisms to define system-specific stereotypes with appropiate icons.
-Model the relationships among these processors and devices in a deployment diagram similarly,specify the relatioship between the components in your system´s implementation view and the nodes too.
-As necessary, expand on any intelligent devices by modeling their structure with a more detailed deployment diagram.

# data[].attributes.body
Nodes are a lot like components: Both have names; both may participate in dependency,
generalization, and association relationships; both may be nested; both may have instances; both
may be participants in interactions. significant differences between nodes and components are.

-Components are things that participate in the execution of a system; nodes are things that
execute components.
-Components represent the physical packaging of otherwise logical elements; nodes
represent the physical deployment of components.

This first difference is, nodes execute components; components are things that are executed by
nodes.
The second difference suggests a relationship among classes, components, and nodes. A
component is the manifestation of a set of logical elements.

# data[].attributes.body
To model an adaptable system you must consider the physical distribution of the components that may migrate from node to
node. You can specify the location of a component instance by marking it with a location
tagged value.
If you want to model the actions that cause a component to migrate, create a
corresponding interaction diagram that contains component instances.

Deployment
UML provides a graphical representation of node. this allows you to visualize a node apart from any specific hardware. represents specific kind of processors and devices.

A "node" is a physiscal element that exist at running time and representes a computational resource. and it's rendered as a cube

# data[].attributes.headline
Common Modeling Techniques / Modeling the Distribution of Components

# data[].attributes.subject
Common Modeling Techniques / Modeling the Distribution of Components

# data[].attributes.body
To model the distribution of components.
- For each significant component in your system, allocate it to a given node.
- Consider duplicate locations for components.
- Render this allocation in one of three ways.
1. Don't make the allocation visible, but leave it as part of the backplane of your
modelthat is, in each node's specification.
2. Using dependency relationships, connect each node with the components it
deploys.
3. List the components deployed on a node in an additional compartment.

# data[].attributes.headline
Common Modeling Techniques / Modeling Processors and Devices

# data[].attributes.subject
Common Modeling Techniques / Modeling Processors and Devices

# data[].attributes.body
Modeling the processors and devices that form the topology of a stand-alone, embedded, client/server, or distributed system is the most common use of nodes.
*A processor is a node that has processing capability.
*A device is a node that has no processing capability.
Characteristics of model processors and devices:
1.-Identify the computational elements of your system's deployment view and model each as a node.
2.- If these elements represent generic processors and devices, then stereotype them as such.
3.- The attributes and operations that might apply to each node.

# data[].attributes.body
according to the model is about :
*relationship of the model with  the logical database schema with respect to classes.
*Select a strategy for mapping these classes to tables.
*create a component
diagram that contains components stereotyped.
*use tools to convert your logical design into a physical
design.

# data[].attributes.body
To model an adaptable system you must consider the physical distribution of the components that may migrate from node to
node. You can specify the location of a component instance by marking it with a location
tagged value.
If you want to model the actions that cause a component to migrate, create a
corresponding interaction diagram that contains component instances.

Deployment
UML provides a graphical representation of node. this allows you to visualize a node apart from any specific hardware. represents specific kind of processors and devices.

A "node" is a physiscal element that exist at running time and representes a computational resource. and it's rendered as a cube

# data[].attributes.body
The component diagrams are a very important diagrams that engineers will often create early in a project. However, the component diagram's usefulness spans the life of the system. Component diagrams are invaluable because they model and document a system's architecture. Because component diagrams document a system's architecture, the developers and the eventual system administrators of the system find this work product-critical in helping them understand the system.

# data[].attributes.body
The most common kind of relationship use among nodes is an association.
An association represents a physical connection among nodes, such as an Ethernet connection or a serial line.
We can include roles, multiplicity, and constraints.

# data[].attributes.headline
component diagram and modeling source code

# data[].attributes.subject
component diagram and modeling source code

# data[].attributes.body
the component diagram are used in modeling physical aspects of the system, also show the organization and dependences among  a set  of components.

modeling source code
to model a system's source code
-identifies the set of source code files of interest and model them as components stereotyped as files.
-For larger systems, use packages to show groups of source code files.
- Model the compilation dependencies among these files using dependencies

# data[].attributes.body
*You can organize nodes by grouping them in packages in the same manner in which you can organize classes and components. *You can also organize nodes by specifying dependency, generalization, and association relationships among them.

# data[].attributes.body
Identify the system´s devices and processors as for simpler client/server.
Pay close attencion to logical groupings of nodes, which you can specify by using packages.
When modeling a fully distributed system, it´s common to reify the network itself as an node.

# data[].attributes.body
it´s a kind of model with respect to component diagram.
this model consistent in the following:
*in a set of artifacts delivered to user
*Release to focus on parts neccesary to deliver running system.
*show the specific components for using in the system.