I'm studing UML and while I was reading what a UML Profile is, I read
"Profile is a profile package that extends a reference metamodel (such
as UML) by allowing to adapt or customize the metamodel with
constructs that are specific to a particular domain, platform, or a
software development method. In other words, profile is a lightweight
extension mechanism to the UML standard."
Source: http://www.uml-diagrams.org/profile.html
I tried to look for the term in Google but I was not able to find anyting.
Thanks in advance.
Andrés-J. Cremades
It would probably best to ask the umldiagrams.org authors what they meant with "lightweight". Actually you can construct quite heavy weight profiles with UML as for example BMPN, SysML, Archimate and others. Their complexity is comparable to UML itself.
Related
Please I need help in understanding this two approaches in the uml world. I am a programmer who is new to uml. I just started learning uml lately but kept getting this phrase asked all the time. - Are you modelling or drawing?. An explanation is needed with clear examples.
This link hinted just a little but I am stil confused -- http://modeling-languages.com/drawing-tools-vs-modeling-tools/
UML is a modeling language, which has a graphical notation. Its semantic is precisely specified by UML 2.5 standard of the OMG and also the international standards ISO 19505-1:2012 and 19505-2:2012 (although the latter corresponds to UML 2.4.1).
THere are two different approaches to UML diagramming. And it's heavily influenced by the tools you use:
Drawing tools generally offer UML shapes to be used in drawings. But there is no deeper meaning behind the shapes. It's only pictures. These tools would allow you to mix a use case with a class or an actor in a deployment diagram. The advantage is that you can do what you want. The inconvenience is that what you want may not be compliant.
Real modeling tools let you combine only valid UML elements together and ensure consistency of what you draw with the deeper meaning of the UML language. And they build a true and comprehensive model behind the scene by combining all the facets of the different diagrams.
Modeling tools can do smarter things. They can relate for example a class to their object instantiations in sequence diagram. They can help you to find all the other models in which a specific class is used. If you rename a class or add a property in one diagram, it'll be automatically reflected in all the others.
Modeling requires more discipline, but it's more powerful in the end. Some modelling tools can even use their understanding of UML to generate code out of the model.
You can use UML diagrams in very free way and you can use them up to the specifications. There are even different UML tools - some support only free style diagrams/drafts, some check dependencies and correctness and thus create models. There are some tools in between (MS Visio is one of them)
Nothing is ideal and fitting for everything. For example, some strict tools (VP and EA) forbid to make number-named classes, but according to UML specification you MUST use number names for anonymous classes. But -sigh- we have what we have.
Use of UML as such is not strictly predefined. So, you can use it for freehand drafts, later work on them more thoroughly and make them models. Or do only drafts. Or only models. But at any moment you should know how strictly are you keeping up to specifications. Or at least, trying to keep up. But even very free draft can help you greatly to understand the task or to think in a more productive way.
Currently i am trying to figure out, then to use OWL and then to use UML to describe a domain of interest in a Software Engineering process.
I read this paper by Atkinson, which gives a very good overview about the difference and the equalities of OWL and UML on a semantic and a syntactic level.
However it does not provide a clear indication in which use-cases it might be better to use OWL instead of - for example - an UML class diagramm.
It might be the underlaying development process, which decides the modelling language to take (e.g. model-driven = go for UML, ontology-driven = go for OWL) but for myself it is this difference still not clear?
In both language I can build up a terminology, which I - as an ontology engineer - can reuse in order to infer new knowledge from it. As an Software Engineer I use this terminology for the construction of a (single) system.
So is the difference between OWL and UML just the field of study? Or could I use OWL in order to describe the construction of my (single) software system?
Moreover, this raises the question if the decision of which kind of modelling language to choose is only driven by the goal, which I try to accomplish?
A synthetic answer
UML is a (graphical) language for modeling
OWL is a language used for knowledge representation (KR) in a semantic perspective
In the first place, OWL purpose is not modeling. Using a KR technique is an option in the field of software engineering. It should be distinct from any software engineering process. Both languages have different purposes.
Of course, you could [use] OWL in order to describe the construction of [a software system]. But the interest of such a move would mainly be in automated reasoning about your software construction process and would not be very helpful in the context of a single project. This would only be effective if done for all your projects in order to have a consequent knowledge base (KB).
A detailed explanation
According to the W3C wiki section about OWL:
The W3C Web Ontology Language (OWL) is a Semantic Web language designed to represent rich and complex knowledge about things, groups of things, and relations between things. OWL is a computational logic-based language such that knowledge expressed in OWL can be exploited by computer programs, e.g., to verify the consistency of that knowledge or to make implicit knowledge explicit
There should be some debate about what is a modeling language. For example, the Wikipedia article on the topic considers a broad sense which could also cover OWL. I consider here with the modeling term only the software engineering activity (which is the one you focus on in your question).
You might need modeling in order to define ontologies, just like you would need for the development of a software project. But this OWL modeling would not consider the software engineering elements but rather the domain data of your project. In other words, using UML in a software construction process aims to setup software elements. With OWL, you would not focus on these elements, unless you are trying automated reasoning about software construction.
Beside this, a relationship exists between UML and OWL. A note by Walter W. Change in the frame of the W3C discusses the question. I would summarize the question considering two distinct relations.
Using UML to represent OWL knowledge
An OMG specification called ODM (for Ontology Definition Metamodel) provides a metamodel for defining ontologies. In the frame of this specification, the use of an UML profile is introduced as a way to bridge a gap between both languages. In the ODM 1.1 specification, section 8.4.2:
The goal of a UML profile from the ODM perspective is to provide a bridge between the UML and knowledge representation communities on a well-grounded, semantic basis, with a broader goal of relating software and logical
approaches to representing information.
The UML profile use is introduced in an article. You might find such a profile in the ODM 1.0 specification resources, as a non-normative document. According to what is here considered, this UML profile might be a tool for modeling ontologies.
Using OWL/Semantic Web technologies to represent UML
RDF is the basis format used to write OWL ontologies.
An early (2000) academic work provides a semantic RDF document modeling the UML elements (based on the OMG specification). This work preceded the draft works on the OWL W3C recommendation (2002).
Actually OWL is available as profile in UML. See OMG specfication. So you can use UML with OWL profile in "one soup".
Let's start with the definitions.
Unified Modeling Language (UML) is a general-purpose, developmental,
modeling language in the field of software engineering, that is
intended to provide a standard way to visualize the design of a
system. (Wikipedia)
UML has many diagrams, but none of the classics is designed for ontology modelling. Therefore, researchers have created OWL with this purpose.
The W3C Web Ontology Language (OWL) is a Semantic Web language
designed to represent rich and complex knowledge about things, groups
of things, and relations between things. (W3C)
Such as said by Thomas Kilian in the other answer:
OWL is available as profile in UML. See OMG specfication. So you can
use UML with OWL profile in "one soup".
Therefore, OWL can be part of the set of UML diagrams used in a Software Engineering Process. The main benefit of OWL over classic UML diagrams is when you have to design a system using ontologies. The purpose of class diagrams is to represent classes, not ontologies. If your system does not rely on ontology, stick with the classic UML diagrams; you do not need OWL. If your system uses ontology and you need to represent it on a diagram, use OWL.
OWL is used to describe a domain and to be able to specifically, using semantics, specify knowledge of a domain as well as describe its specificities. Take for example the Friend of a Friend ontology. Using it you can describe how people relate to each other.
You might say that you can do the same thing using UML and you are correct. You can specify properties, relations, and so on, using OWL as well as UML. However, what you can't do with UML is infer domain knowledge. OWL, being a Semantic Web language, models a domain with either an Open or Closed World assumption. Basically you assume knowledge based on what is described in the domain. Then you can use specific instructions to infer knowledge using Rules or just be looking at predicates and statements you have created. Furthermore, you can use specific query languages such as SPARQL to query your ontology as much in the same way you would use SQL to query a database.
TL;DR: Using UML you specify how you would translate a specific domain into software, using OWL you specify knowledge about the domain as it is much richer than UML.
To amend the references of UML and OWL comparison there is a PhD thesis (in German) from Jesper Zedlitz Konzeptuelle Modellierung mit UML und OWL – Untersuchung der Gemeinsamkeiten und Unterschiede mit Hilfe von Modelltransformationen
(Conceptual Modeling with UML and OWL - Exploring the Similarities and Differences Using Model Transformations)
In this thesis studies if and in which extend it is possible to tranform between both modelling languages. In the conclusion (p. 222) it is stated that OWL has possibilities to do more complex modelling and therefore it is not always possible to transform from OWL to UML.
Actually from my work on ontologies in the previous time I see using ontology tools like Protege is very helpful and rich in describing relations between entities and using Tools like OLGA can help you in mapping this ontology to many object oriented language.
Yes, we haven't the capabilities of using graphical representations to design our models like UML but it provides a wide range of options to describe you model.
The importance and benefits of mapping the domain ontology to the UML model are in integrating the benefits and quality that these two modeling techniques provide. That is, if there are already domain ontologies with a certain level of authority, these knowledge bases can help in the creation of UML class diagrams, such as the axiomatic guarantees provided by the description logic that builds it, besides enabling UML power of inferences Provided by this formalism, with the transformation is intended to show the evidence that reuse of ontology can help to reduce ambiguity in class diagrams.
Is it appropriate to think of UML as a DSL?
I know that everybody thinks of UML as a way to draw pictures, but underlying the "view" of UML diagrams there is a model...and the "L" in UML stands for Language.
Another question - is SysML a DSL?
UML is a DSL.
A "domain specific language" lets one specify a problem or a solution in a narrow area of application; banking, telephony circuit design, .... One way to distinguish a DSL is that it cannot do general purpose computation (although there are some DSLs that can). Java, C#, Python and COBOL fail this test. (Some would say COBOL is domain-specific for "business" but its only serious concession to that is a decimal data type, and C# has that too.) ColdFusion fails this test; nonstandard syntax does not a DSL make, but IIRC ColdFusion has some support for generating HTML. Fortran fails this test, but its array(-section) sublanguage is only good for arrays and not general purpose computation. Verilog is very domain specific: it is designed to let you write down digital circuits.
UML focuses on specifying different aspects of how software is structured. [You'll note it can't do general purpose computation; one hallmark]. (It actually has 9 or more different aspects it addresses: classes, statecharts, deployment, ... I'll stick to the class aspect for this discussion). The class diagram aspect lets one describe how data is organized, and operations on that data. You can argue this about software so it can't be "domain-specific". What, building software isn't a problem domain?
SYSML is focused on expressing how systems are joined, so it fits this category too.
A more useful question to ask IMHO is, "If I think of UML as a DSL, what do I gain?" Here I don't think you get a lot. The concept of DSL is useful when you arguing for one you don't have (designed or possess) with the point being better expressiveness for a common problem, and might be useful for arguing "you don't want implement your system entirely in it because it isn't Turing capable". It is also useful if you want to explain that your language is going to have a lot of funny notations, precisely because they serve special purposes. People already know this about UML, so... nothing learned.
While I'm a big fan of DSLs, I'm also a big fan of GPLs (general purpose languages). I think in big systems you should necessarily find a "lot" of both: the DSLs to express what they can succinctly (cuts engineering and maintenance costs), and the GPLs to provide arbitrary computation and glue between the system parts. For me what counts in a language is:
what's the class of problem it claims to address and how well does it do it?
what's the syntax (and is it relatively standard for the problem domain)?
what are the precise semantics (this is where you learn the most)?
how good is the tool support?
how well does the DSL integrate into other parts of a big system?
how big and supportive is the community?
UML has (after 15 years) arrived at pretty good answers to these questions.
Homegrown DSLs often don't do so well, partly due to poor design, but often due to the fact that tool support is difficult to get. My company provides machinery to give DSL builders excellent support to improve this situation.
UML is NOT a DSL because UML can be used to model any vertical domain (insurance software, embedded systems,...)
UML is a (horizontal) DSL because UML is a specialized language to model software systems.
So UML is and is not a DSL depending on how you look at it. You could apply the same reasoning to many other languages like html or SQL. They are general because they can be used to represent/manipulate any kind of data but they are specific because they are focused on one task
Short answer - NO - to both questions.
Think of UML as a tool that lets you describe software architectures, software interactions and so on ... describe them in a general way, language agnostic.
DSLs are specialised syntaxes meant to make it easier to describe some specific set of problems
I think the answer to your first question depends on how to define "General" in the term "General Purpose Language". Wikipedia says it is not a DSL:
The opposite is:
a general-purpose programming language, such as C, Java or Python,
or a general-purpose modeling language such as the Unified Modeling Language (UML).
I am a MDA enthusiast so I think I can provide you a very detailed answer to your question.
What is the UML:
The Object Management Group (OMG), a consortium of companies aimed at providing standard languages and technologies, defined a meta-meta modeling language called "The Meta Object Facility" or MOF (http://www.omg.org/mof). A meta-model is a model describing a model or, in other terms, describing the vocabulary (the elements you can use in a model), the syntax (ho they relate each other) and their semantics (what does each entity mean and how its meaning changes in a given context, etc.). A meta-model plays the same role played by Context-Free grammars with respect to the languages they produce. You can thus think at a meta-meta model as a language you can use to define meta-model. This is what the OMG actually did with the UML. The UML language has a meta-model described by means of the MOF in two documents: The UML Infrastructure and the UML Supersturcture (http://www.omg.org/spec/UML).
The UML meta-model has been defined with the aim of been generic enough to cope with the modeling of different systems belonging to different domains. When you define a new UML model you create an instance of the UML meta-model. You could do that for many reasons: to analyse some characteristics of the system, to share some aspects of the system with other stakeholders and so on. However, one of the most important aspects of the OMG vision are model transformations. You can think at a transformation as a set of rules telling an interpreter how to explore a model and produce something else. You can basically transform a model into two different kind of thins, other models (Model2Model, M2M transformations, defined by means of the QVT language) or text such as code or documentation (Model2Text, M2T, transformations defined by means of the MOFM2T Transformation language). So it is VERY IMPORTANT to understand that a UML model is not its diagram. A diagram is just a pictorical representation of the model contents, useful for umans, but not machine readable. You can't apply transformations to a diagram.
The Eclipse Modeling Framework (EMF) is a very powerful (and FREE!) framework implementing all the technologies I have mentioned. A subset of the MOF is implemented in the Eclipse ECORE language. By means of the ECORE the UML meta-model is defined so grafical UML editors (i.e. Papyrus, TopCased, etc.) actually creates XMI representation of the graphically defined UML models conform to the ECORE representation of the UML meta-model. Such representation can be provided as input to transformations engine. The two transformation languages, and related engines, are also available in the EMF with the QVTo plugin and ACCELEO (implementing the MOFM2T transformation language).
As mentioned UML is intentionally generic. However it also provide lightweight extension mechanisms to extends original language vocabulary with domain specific constructs. This can be done by means of stereotypes. A stereotype is a sort of label (actually with meta-attributes) you can attach on model elements to create new entities in the language. You can for instance say in your models some of the classes could be requirements or something else. There are of course some rules, for instance when you stereotype a meta-class you can not violate its original semantics, just reduce it.
SySML is a profile of the UML http://www.omgsysml.org/. A SysML Block is just a UML class stereotyped as Block, a SysML Requirement is just another UML class stereotyped as Block and so on.
Profiling a meta-model like the UML is a quite easy way of creating a sort of DSL (as with stereotypes you add to a more general language some constructs which belong to your domain) which is compatible with the UML (i.e. you can use SysML and UML together). There is another way of creating a DSL which is defining its meta-model by means of the MOF (ECORE). In this case you create a brand new language which is conceptually at the same level of the UML itself.
Many people say UML is just about diagrams because in many cases they do not know what they are talking about. The topic is far more complex, interesting and promising.
UML is a general modelling language that is not specific to any domain whilst the S in DSL stands for Specific. UML is used for modelling systems that can also be represented by multi-purpose programming languages. DSL on the other hand are constrained programming/scripting languages which are specific to a particular domain.
I was hoping you could tell me what the advantages and disadvantages of BPMN are in a developers perspective.
I'm comparing UML with BPMN and a found a bunch of advantages and disadvanteges for UML but none for BPMN.
It's largely down to audience and purpose. In terms of modelling language, BPMN and UML activity diagrams cover pretty much the same conceptual space with different notations. The notation thing gets religious very quickly. I personally prefer AD notation over BPMN - but it's a very personal thing.
Broadly speaking, BPMN tends to find favour with those coming from a business process modelling / business analysis background. UML ADs tend to be favoured by those coming from a software perspective. Tool support tends to mirror this: the high end process modelling tools (casewise, aris, etc.) are more likely to support BPMN; software modelling tools (MagicDraw, Sparx, etc.) favour UML. However there's increasing crossover there. I've used both with business stakeholders with no issues in either case.
Finally is purpose. Are your diagrams going to be for human consumption only or used as a specification for some form of analysis/code generation? If it's not just pictures then your tool chain may well be the deciding factor.
If you want a more detailed description of the differences, have a look at the answer in this forum post.
A new BPMN Profile has been discussed at the OMG. UML can easily generate code even with an activity or state diagrams. You just need to add stereotypes in your model then a parser will take the xmi and create code. The OMG specification will define which stereotypes should be used and why. Really a very good idea !!
In my company we have stopped using BPMN and are only focus on the activity diagram which is more accurate because built on the top of a standard language. Having also class diagram, usecase and activity diagrams allows to model faster.
We get a running code from our activity or state diagram. We debug with our class diagram.
We use the same metamodel for all diagrams and therefore can trace activity to code implementation and through class diagram. I mean that the code is reversed once generated and then we check all requirements and the architecture in order to have a nicer object architecture.
Everything works well :-)
We are now waiting for the new profile specification and will implement the needed stereotypes in order to cover BPMN.
My answer to your question is that we don't need anymore BPMN and should move on to UML 2.3 BPMN profile implementation.
BPMN is for modeling business process flow, isn't it? That's not exactly what UML is for. The goal of UML is to model a software from different view and ultimately not to have to code it (yes that's kind of ideal).
The main arguments for BPMN from a business perspective are usually:
When building BPMN diagrams from scratch with many stakeholders, it is ok to mix tasks of different levels of hierarchy, which can be detailed out or summarized later.
The basic language elements can be thought quickly even to a non-technical audience.
The developers can immediately start working and attaching source-code and scripts to the BPMN-diagram by workflow and business process management software like Camunda.
The main drawbacks are that
The initial BPMN sketch (usually by the business) usually needs many iterations to arrive at a diagram which allows for implementation.
It is not straight forward to represent different roles since the usual concept of lanes in pools might not be enough or lead to huge diagrams, see e.g. BPMN: multiple roles in a row
See the MDA on OMG (Model Driven Architecture):
- we use BPMN only for Computation Independent Models (CIM)
- we use UML only for Platform Independent Model (PIM, high level design) and Platform Specific Model (PSM, low level design).
- using BPMN for any "software systems" or UML for "business" have no sense (see UML v.2.5)
- for developers: we can make transition from BPMN business process to Use Case, it is good tool for defining scope of requirements for software https://www.visual-paradigm.com/tutorials/from-business-process-to-use-cases.jsp
If you are looking for similarities, both UML and BPMN diagrams can be described using text.
PlantUML
BPMN Sketch Miner
I'm designing a software component which will get instructions from other components on how the UML diagram should look like, and then will produce this UML diagram in different presentation ways (in SVG, GIF, etc.), for example (in Java):
DiagramDesigner designer = new DiagramDesigner();
designer.setStyle('Use Cases')
designer.addActor('User');
designer.addUseCase('Print Document');
// etc.
String svg = designer.getSvg();
I don't want to re-invent the wheel and want to use some industry-standard language/interface for interconnection between my DiagramDesigner and other components. I'm looking for an interface similar to DOM, but for UML, not for XML.
Can anyone help? Thanks in advance.
ps. Besides the example above I would like to make my diagrams inter-operable and transferrable between servers, e.g.:
// first server
String script = designer.getScript();
// second server
DiagramDesigner desiger2 = DiagramDesigner.import(script);
So if I understand you right, you are looking for a way to work with UML on the metamodel level. You should look at the MOF standard and its implementation the EMF (Eclipse Modeling Framework), which is used by almost all Eclipse based UML tools and this framework is used by many other modeling projects, it even somewhat influenced the standardization of MOF (resulting in SMOF and EMOF split) and therefore I would declare it industry standard.
Probably only loosely related but anyhow: PlantUML. It is open source, built in Java and likely contains already parts of what you want to do.
You can inspire from these scripts to generate any output you want:
http://askuml.com/
Currently examples are given in yUML because they're nice but could be anything.
At least for the syntax part, you could get some inspiration from the large set of textual UML tools (theses tools allow designers to textually specify the model and then they automatically show the model graphically using the standard UML notation).
At least of such tools here: http://modeling-languages.com/content/uml-tools#textual