My deployment diagram has a device with a Windows ExecutionEnvironment in it. The application uses several dynamically loaded libraries, some of which are deployed with the application, others into the system itself.
How are dynamically loaded libraries normally represented in deployment diagrams?
My current theory is my application gets its very own execution environment within the Windows where I deploy my application specific dynamically loaded libraries, and have the system libraries deployed outside it:
For above diagram the system has v1 of libraryA and libraryB installed, and v2 of libraryA is deployed with the application, shadowing the system version.
Your approach makes perfectly sense:
ExecutionEnvironments represent standard software systems that application components may require at execution time.
Moreover:
Artifacts elaborate and reify the abstract notion of DeployedArtifact. They represent concrete elements in the physical world, may have Properties representing their features and Operations that can be performed their instances, and may be multiply-instantiated so that different instances may be deployed to various DeploymentTargets, each with separate property values.
This applies perfectly to dynamic libraries, where there is one library loaded by the OS and that may be used by multiple applications, each in its own address space.
Some hints:
You could use the «Library» and «Executable» stereotypes of the UML standard profile to better distinguish different kind of artifacts.
You could add the dependency from the executable to the required libraries
Related
I am designing an UML diagram for an Apple Watch Extension. How should I represent host app using UML ? UML Node or UML component ? Please note that there can be inter app communication between the extension app and the iPhone app (host app).
UML nodes are apparently used to depict physical resources, so your watch would be a node, whereas a component is usually understood as a software component. Since you want to model software, go with components (which will also nicely visualise the plugging between extension and host).
uml-diagrams.org explains the basic difference as "node is a deployment target" while "component is a structured class representing a modular part of a system"
They're typically used in different kinds of diagrams with different purposes. e.g. in UML Class Diagram both extension app and iPhone app would be represented as UML Class
You can, however, create your custom diagram mixing whatever UML artifacts you need - to make your design message clear to the readers
-Node represent the physical part of the system. for instance , server ,network and printer etc.
-Component represent any part of the system it might be physical aspect such as libraries ,file ,executables,document,packages etc that reside on the node.
-Component - refers to a module of classes that represent independent systems or subsystems with the ability to interface with the rest of the system.so it tells who does the system functionality.
Components are things that participate in the execution of a system; nodes are things that execute components.
Components represent the physical packaging of logical elements; nodes
represent the physical deployment of components.
would it be possible to implement a layer managing several running programs on the basis of LLVM-IR?
Background: I have several small programs (which should be coded in IR directly or tranformed from clang to IR). They might get altered on IR level, then should be compiled on/for a given architecture and run there (in parallel).
There should be a central instance, which supervises the individuals, possibly spawning new individuals. Interprogram communication should be possible.
Not using IR, i could use c/c++ and some system specific threading/message passing tools.
If I understood correctly, I could translate the code to IR; but if IR is targetagnostic, would'nt this fail? If not this means that there should be IR level tools for inter program communication...
So I'm confused about this. I read through the LLVM documentation but did not get it clear so far. Any hints?
UPDATE:
So far I found a possible (target dependent) solution.
On could code the managing layer in clang, using the clang interpreter (jit) approach for the individuals which were 'jitted' and then spawned as threads (e.g. using pthread) by the managing layer.
If I understood correctly, the target specific part enters the IR code as externals. In this sense IR is not platform agnostic, as the resulting IR from a given clang code makes use of the platform specific includes.
Using newlib, one gets standard clib functionalities as source, applicable for several targets.
So using newlib+clang, the IR is not platform independent, but the process from source to final machine code is flexible (among the available newlib&llvm targets).
Right?
How about generating threads with round-robin type scheduling? I guess this will be platform dependent (e.g. by using pthread).
Right?
I've developed a heterogeneous application which takes advantage of service oriented architecture. It consists of many components which are different in code and run in different platforms (example: an Android Client, a WP8 Client, a Web Server, a Desktop Client, a Website).
Now I'm trying to document that I have concluded to put each component in a separate subsystem. But I have come across the question of whether putting DLLs also in subsystems or not. This application consist of many DLL files and I can't really decide on this. I also have another question, since the main applications need to make use of class libraries like DLL, if I wanna show this relationship in the use case (all function in the main apps rely on the function in the DLL, and the functions in the DLL files cannot be executed separately), so is this "Include" or "Extend".
For example:
DLL A = Generates Machine ID
Desktop App uses the DLL A to register the Machine
So is this "Extend" or "Include" (I think include is right but wanna double check)
Depicting DLL-s in use case level is not something you do every day. I would forget about DLL and I would just simply write what those specific DLLs do (if somebody from "business" reads your documentation, he or she would not care about DLLs anyway, if this is a technical documentation, use Deployment or component diagram for this purpose).
From my understanding all DLLs do the same but runs on different platform, am I correct? If so, then just draw one use case and use include.
Why include, not extend? Extend is for eg. there is a use case which comprises other steps on specific condition whereas include means that specific use case is the same in different use cases.
What is the difference between the next terms, it can help a lot in interviews and general understanding.
Framerwork
Library
IDE
API
Framework
Some predefined architecture that a developer has chosen and which dictates how the application will be written. It usually already includes many concepts which helps the developer to concentrate on the domain of the application instead of the plumbing. This plumbing is provided by the framework. For example the .NET framework provides out-of-the-box tools that would allow you to talk to web servers, without even knowing the internals of the TCP/IP protocol (actually it helps knowing the internals but you get the point).
Library
A reusable compiled unit that can be redistributed and reused across various projects. Well not necessary compiled in case of dynamic languages.
IDE
It's the development environment where you create the other three parts (usually text editor), it might also include compiler and the possibility to execute, debug and see the output of the program in order to speed up the development process.
API
Application Programming Interface. This could mean many things but usually it is a set of functions given to the disposition of the developer and which perform specific tasks and work only in a specific context.
IDE is a tool for fast, easy and flexible development
An API is provided for an existing software. Using these third party applications can interact with main/primary application.
A framework or library are typically same. They are a common set of functionality for other software to use.
Ref: wiki for Framework, API
Framework: a collection of libraries and programming practices to provide general functionality for a program, so that it doesn't have to be rewritten. Typically a framework for an application program will handle user display and input, among other things. The intent is usually to hide the more complex functionality of an application, and to encourage a certain style.
Library: A piece of software to provide certain functionality to other programs that call it. Typically designed to be reusable and modular, so that a library can be distributed and be useful without its source code.
Integrated Development Environment: A integrated set of tools to write programs and turn them into finished products, usually including at least an editor, compiler, linker, and debugger. IDEs sometimes provide support for frameworks.
Application Programming Interface: A set of function calls and sometimes variable accesses available to a program, typically being the public interface of one or more libraries.
What are the Differences of Component Diagrams and Deployment Diagrams?
Simply put, a Component diagram shows you how different elements of your system have been grouped together (into assemblies / dlls etc) - and the link between these components. A Deployment diagram takes you one step further and describes on which hardware elements do these components reside.
So for example, if "Utility.dll" is a component and say it is deployed on the Client Machine (hardware). Then, the Component Diagram of this system will show Utility and its link with other components in the system (say.. Customer / SQL Packages). Whereas, the Deployment Diagram will show the hardware configuration - DB Server / Web Server / Client Machine .. and Utility component will be placed into the Client Machine Node.
Component Diagrams are used to diagram the high level components which you will be developing. For example , in my application, i use COM to separate the modules. Each COM object runs in its own executable and is a modeled as a component.
Deployment Diagrams are used to diagram the actual runtime modules which are required to complete the system. This include your modules and any hardware / software which is required to complete your system. In my application, the Deployment diagram will contain the names of all the servers and which modules they will be running.
A component diagram describes the organization of the physical components in a system.
Deployment diagrams depict the physical resources in a system including nodes, components, and connections.See for example here http://vinci.org/uml/