Skip to content

Feed aggregator

Hackolade Introduces First Data Modeling Software Tool For Couchbase NoSQL Databases

Unified Modeling Language (UML) Zone - 11 hours 52 min ago
Hackolade, the pioneer for data modeling for NoSQL and multi-model databases, announced the introduction of the first data modeling software tool for the Couchbase NoSQL database community. This software is compatible with Couchbase versions 4.0 through the latest 4.6 release. Standard features of Hackolade, already popular with NoSQL database users, have been adapted to support the specifications of Couchbase. Users for the new release of Hackolade vary depending on the size of the development project, but it’s typically best suited for larger organizations with IT architecture and data governance departments engaged ...
Categories: Communities

iOCL: Write your OCL constraints interactively

Software Modeling Blog - Thu, 03/23/2017 - 07:00

iOCL is a new tool that helps you write OCL constraints faster and minimizing the chances you get them wrong thanks to its interactive mode

The post iOCL: Write your OCL constraints interactively appeared first on Modeling Languages.

Categories: Blogs

Verplicht leuk doen

Sander Hoogendoorn - Mon, 03/20/2017 - 17:21
Verplicht leuk doen Enkele maanden geleden had een goede vriend een kennismakingsgesprek bij een gerenommeerde webwinkel. Het grotendeels blauw ingerichte kantoorpand viel op. Vrijwel alles was gelabeld. De koelkast, de snoepautomaat, de koffieautomaat. Als een aanleunflat van een Alzheimer-patient. Maar er was meer. Alle labels werden ook nog eens begeleid door kwieke one-liners. Allemaal onder het motto: kijk eens hoe […]
Categories: Blogs

Agile beyond refinements

Sander Hoogendoorn - Sat, 03/18/2017 - 17:20
Even though the year is still young and still cold, I have already presented two training courses. One on microservices for a transportation company. And one on agile for teachers at a high school who want to adopt agile techniques to their classes. Although the topics were quite different, attendees at both courses had a similar background in doing agile: […]
Categories: Blogs

Convention over configuration – key selling point for MDE

Software Modeling Blog - Wed, 03/15/2017 - 06:45

Convention over configuration aims to simplify development by decreasing the number of decisions developers need to make. MDE has a similar goal. Let's see how to combine them.

The post Convention over configuration – key selling point for MDE appeared first on Modeling Languages.

Categories: Blogs

List of Executable UML tools (2017 update)

Software Modeling Blog - Thu, 03/09/2017 - 01:58

Complete list of executable UML tools for the fUML OMG standard and other UML executable languages

The post List of Executable UML tools (2017 update) appeared first on Modeling Languages.

Categories: Blogs

Interview with Gaël Blondelle on Eclipse and its modeling ecosystem

Software Modeling Blog - Thu, 02/23/2017 - 07:27

To talk about the Eclipse modeling ecosystem, we are joined today by Gaël Blondelle, Director of European Ecosystem Development at the Eclipse Foundation.

The post Interview with Gaël Blondelle on Eclipse and its modeling ecosystem appeared first on Modeling Languages.

Categories: Blogs

Model-based Analysis of Java EE Security Configurations

Software Modeling Blog - Tue, 02/21/2017 - 06:07

Our work helps security experts to visualize, (automatically) analyse and manipulate web security access-control policies, specially for Java EE

The post Model-based Analysis of Java EE Security Configurations appeared first on Modeling Languages.

Categories: Blogs

OCL Workshop 2017 – Recent developments in OCL and Textual Modeling

Software Modeling Blog - Tue, 02/21/2017 - 05:02

The meeting place for all kinds of discussions and new proposals around the world of OCL and textual modeling languages

The post OCL Workshop 2017 – Recent developments in OCL and Textual Modeling appeared first on Modeling Languages.

Categories: Blogs

OpenPonk (meta)modeling platform

Software Modeling Blog - Thu, 02/16/2017 - 09:08

OpenPonk is a free and open source experimental (meta)modeling platform built in the Pharo live environment aiming to create a live, programmable modeling platform for both serious work and fooling around.

The post OpenPonk (meta)modeling platform appeared first on Modeling Languages.

Categories: Blogs

Grand Challenges in Modeling (2017)

Software Modeling Blog - Tue, 02/14/2017 - 16:32

First workshop ever focused on discussing the grand challenges in modeling and model-driven engineering. Don't miss it!

The post Grand Challenges in Modeling (2017) appeared first on Modeling Languages.

Categories: Blogs

PyEcore: a Python(ic) Implementation of the Eclipse Modeling Framework

Software Modeling Blog - Tue, 02/07/2017 - 04:53

Looking for an alternative to the "standard" Java-based Eclipse Modeling Framework? Try this Python implementation of EMF with an emphasis on modeling flexibility and scripting (e.g. to write model transformations)

The post PyEcore: a Python(ic) Implementation of the Eclipse Modeling Framework appeared first on Modeling Languages.

Categories: Blogs

The best UML book (and you didn’t even know it existed)

Software Modeling Blog - Wed, 02/01/2017 - 18:27

Allow me to explain why this book is the best UML book you will find. You can thank me later.

The post The best UML book (and you didn’t even know it existed) appeared first on Modeling Languages.

Categories: Blogs

Building better software faster

Sander Hoogendoorn - Mon, 01/30/2017 - 16:30
On January 10 I presented my first talk of the year 2017 at the annual kick-off at insurance software vendor ANVA in Amersfoort, the Netherlands.   The main topic is building better software faster and covers agile, (beyond) Scrum, Kanban, continuous delivery and microservices.   Building Better Software Faster from Sander Hoogendoorn
Categories: Blogs

Six Negative Results in Software Engineering – EMSE Special Issue (published)

Software Modeling Blog - Mon, 01/30/2017 - 13:04

Negative or null results are hardly ever published though they are important in showing the paths which did not pay off. This special issue is a first step to change this

The post Six Negative Results in Software Engineering – EMSE Special Issue (published) appeared first on Modeling Languages.

Categories: Blogs

Generating UML Reports From XMI Files

SDMetrics - UML design quality measurement - Mon, 02/24/2014 - 10:40

Occasionally I receive requests from people looking for a simple way to generate a report from an XMI file. For example, they may need to collect a list of all class attributes that satisfy a certain condition, and write them to some HTML or XML file. Depending on the task at hand, XSLT could work in such situations, especially if it’s a one-off problem to solve, the XMI files are not very large, and come from a single source. Another option is to use the report generation facilities that some UML modeling tools offer.

But what if you’re dealing with huge XMI files, possibly from different sources? Or the report depends on information contained in proprietary XMI extensions that your UML modeling tool does not import? Or you need to evaluate complex conditions or constraints on the UML model elements for the report? That’s what SDMetrics was designed for. However, SDMetrics does not have a report generation facility. You could use SDMetrics’ API and write a Java program to generate the report. That requires Java skills, and the solution must be recompiled and redeployed every time the report needs to be changed. A more flexible solution is to use a Java-based template engine such as Velocity for report generation.

In this post, we will develop a Velocity template for SDMetrics to generate an HTML report for a UML model. The report will list

  • every UML model element in the model, along with the values of its attributes,
  • the metric values for each model element,
  • the contents of the helper sets for each model element (for example, the set of ancestor/descendant elements),
  • the list of rule violations of the model element, if any.

Here’s a preview of what the report will look like. In this form, the report is not yet particularly useful or appealing. However, the main purpose of this post is to demonstrate how to include all the model information in the report using the SDMetrics API. The template we are about to write can thus serve as a starting point for developing customized reports more quickly.

To execute the report generator, we need

We also need a Java compiler or IDE to compile the glue code that hooks up Velocity with the SDMetrics API, and a Java 1.7 runtime for execution. I have prepared a ZIP archive for download that contains the libraries, glue code, and the finished template, ready to compile and run.

Define a report facade

Java template engines provide a scripting language to access Java objects, and invoke methods on these objects to traverse the data structures for the report. In the SDMetrics API, the interesting Java classes for report generation are:

I found it useful to implement a single Java class that serves as facade to the container classes (MetaModel, Model, MetricStore, MetricsEngine, RuleEngine). That way, the report template author does not have to deal with these five objects individually, but can rely on a single class that provides all the data. Let’s call this class ReportFacade. Here’s an excerpt from the class:

import com.sdmetrics.metrics.*;
import com.sdmetrics.model.*;
import java.util.*;

public class ReportFacade {

  private Model model;
  private MetaModel mm;
  private MetricsEngine me;
  private RuleEngine re;

  // Access to the metamodel

  public List<MetaModelElement> getTypes() {
    List<MetaModelElement> typeList = new ArrayList<>();
    for(MetaModelElement mme : mm)
      typeList.add(mme);
    return typeList;
  }
  
  // Access to the model

  public List<ModelElement> getElements(MetaModelElement type) {
    return model.getAcceptedElements(type);
  }
  
  public List<ModelElement> getRootElements() {
    ArrayList<ModelElement> roots=new ArrayList<>();
    for(ModelElement me : model)
      if(me.getOwner()==null)
        roots.add(me);
    return roots;
  }
  
  public boolean isModelElement(Object o) {
    return o instanceof ModelElement;
  }
  
  // Access to metrics and sets
  
  public Collection<Metric> getMetrics(MetaModelElement type) {
    return me.getMetricStore().getMetrics(type);
  }
  
  public Object getMetricValue(ModelElement e, Metric m) {
    return me.getMetricValue(e, m);
  }
  
  ...
  
}

The methods of the facade class mostly just delegate to the respective getter methods of the container classes. Where necessary, objects are filtered or placed into collections so that the report template can access them.

Creating the report structure

Let’s start with the template. The following code snippet generates the overall structure of the report:

<?xml version="1.0" encoding="$encoding"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 

[... skip macro definitions for now ...]

<html>
<head>
<title>$title</title>
<style type="text/css">
table { border-collapse:collapse; }
table,th,td { border: 1px solid black; text-align:left; }
</style></head>
<body>
<h1>Overview of elements</h1>
#writeElementHierarchy($report.getRootElements())
#foreach( $type in $report.getTypes() )
  #set( $elements = $report.getElements($type))
  #if($elements.size() > 0)
    <h1>List of elements of type '$type.getName()' ($elements.size())</h1>
    #foreach($element in $elements)
      <a name="$element.getXMIID()">
      <h2>$type.getName() #escp($element.getFullName())</h2></a>
      #writeAttributes($element)
      #writeMetrics($element)
      #writeSets($element)
      #writeRuleViolations($element)
    #end
  #end
#end
</body>
</html>

The template writes the boiler plate markup for a valid XHTML 1.0 file, with <html> and <head> tags and a little CSS styling. The variable $encoding contains an externally provided string with the character encoding for the output file (for example “UTF-8″). Likewise, variable $title provides the title for the report.

Next is the body of the report. The macro #writeElementHierarchy() recursively writes the nested list of model elements that serves as a “table of contents” of the report. We’ll look at its definition in a moment. Variable $report is an externally provided reference to our ReportFacade instance that holds the UML model. Method getRootElements() obtains a list of all model elements that have no owner. All other elements in the model are directly or indirectly owned by the model elements on this list.

After that, the templates goes into a foreach-loop over all element types in the meta model ($report.getTypes()). The body of the loop creates, for each element type, a list of all model elements for that type ($report.getElements()). For each model element, we write an <h2> tag with the type and name of the model element, and a named anchor to cross-reference model elements within the report using hyperlinks. The XMI IDs of the model elements serve as anchor names. The macros #writeAttributes(), #writeMetrics(), #writeSets(), and #writeRuleViolations then output the detailed information for each model element. So let’s have a look at those macros.

Write the element hierarchy

This is macro #writeElementHierarchy(), along with two little helper macros it requires:

#macro( escp $text )$reportUtils.xmlEncode($text)#end

#macro( writeElementRef $elem )
  #if( $elem )
    <a href="#$elem.getXMIID()">$elem</a>
  #end
#end

#macro( writeElementHierarchy $elements )
  #if($elements && ($elements.size()>0))
    <ul>
    #foreach($element in $elements)
      <li>#escp($element.getType().getName()) #escp($element.getName()) -
        #writeElementRef($element)
        #writeElementHierarchy($element.getOwnedElements())
      </li> 
    #end
    </ul>
  #end
#end

The macro receives a list of model elements as input parameter. The list may be empty or null. The macro produces an unordered HTML list (<ul>) with the type and name for each model element, and a hyperlink to the detailed description of the model element (call to macro #writeElementRef()). If an element owns sub-elements, those elements are written out recursively in a nested, unordered list.

Macro #escp() replaces XML special characters (<, >, & etc) with their predefined entities. For simplicity, we use a little utility class of our own (ReportUtils, not shown here) for that. Velocity comes with an optional tools package (Velocity tools) that also provides this functionality and should be used instead in a production environment.

Write the attribute values

To generate a table with the values of all attributes of a model element, we define macro #writeAttributes() as shown below. It takes the model element to write as input parameter. The macro determines the type of the model element, obtains the list of the attributes for that type, and writes out an HTML table with the attribute names in the first column, and the attribute values in the second column.

#macro( writeElementRefs $elems )
  #if($elems) 
    #foreach($elem in $elems)
      #writeElementRef($elem)#if( $foreach.hasNext ),#end
    #end
   #end
#end

#macro( writeAttributes $elem )
  #set ($elemType = $elem.getType())
  #set ($attributes = $elemType.getAttributeNames())
  <table><tr><th>Attribute</th><th>Value</th></tr>
  #foreach($attribute in $attributes)
    <tr><td title="#escp($type.getAttributeDescription($attribute))">#escp($attribute)</td><td>
    #if($elemType.isSetAttribute($attribute))
      #if($elemType.isRefAttribute($attribute))
        #writeElementRefs($elem.getSetAttribute($attribute))
      #else
        #escp($elem.getSetAttribute($attribute))
      #end
    #else
      #if($elemType.isRefAttribute($attribute))
        #writeElementRef($elem.getRefAttribute($attribute))
      #else
        #escp($elem.getPlainAttribute($attribute))
      #end
    #end
    </td></tr>
  #end
  </table>
#end

Writing the attribute values requires a bit of attention. The SDMetrics meta model distinguishes between data and reference attributes. Data attributes carry string values, reference attributes contain references to other model elements. An attribute can be single-valued or multi-valued.
Multi-valued attributes contain a set of values, single-valued attributes just one. The nested #if-statements in macro #writeAttributes() determine which combination of data/reference and single/multi-valued attribute applies, and obtain the values accordingly. Helper macro #writeElementRefs() is used to generate a comma-separated list of hyperlinks for multi-valued reference attributes.

Write the metric values

Macro #writeMetrics() below creates the table with the metric values for a model element. The macro determines the list of metrics for the element type, and writes out an HTML table with the metric names in the first column, and the metric values in the second column. Metric values can be strings, numbers, or references to other model elements. Helper macro #writeValue() checks if a metric value is a model element reference or not, and either writes a hyperlink to the model element, or just the plain metric value.

#macro( writeValue $value )
  #if($value)
    #if( $report.isModelElement($value) )
      #writeElementRef($value)
    #else 
      #escp($value) 
    #end
  #end
#end

#macro( writeMetrics $elem )
  #set ($elemType = $elem.getType())
  #set ($metrics = $report.getMetrics($elemType))
  #if($metrics.size() > 0)
    <h3>Metrics</h3>
    <table><tr><th>Metric</th><th>Value</th></tr>
    #foreach($metric in $metrics)
      <tr><td title="#escp($metric.getBriefDescription())">#escp($metric.getName())</td>
      <td>#writeValue($report.getMetricValue($elem,$metric))</td></tr>
    #end
    </table>
  #end
#end

Macros #writeSets() and #writeRuleViolations to write the helper sets and rule violations for a model element work in the same fashion and are not shown here.

Give it a spin

To play with the template, the zip archive (1.3 MB) contains a self-contained Java project with everything you need. It is an Eclipse project, but you can also import it in Netbeans or IntelliJ IDEA:

  • The Java source files are in the “src” folder.
  • Make sure the two jar files in the “lib” folder are included in the project’s class path.
  • File “sdmetricstemplate.vm” in the project’s root directory contains the Velocity template.
  • Class com.sdmetrics.velocity.ReportLauncher has a main method that applies the template to the XMI file “sample.xmi” in the project’s root directory.

The support for report generation can be taken further. For example, it is easily possible to define metric or condition expressions directly in the template, have them evaluated on-the-fly by the metrics engine, and include the result in the report. I’ll demonstrate this in a future post.

Categories: Companies

Counting OCL Expressions in UML Classes

SDMetrics - UML design quality measurement - Thu, 01/09/2014 - 14:03

In this post we’ll look at another real-life case study of how to adapt SDMetrics in order to solve a particular measurement problem. An SDMetrics user needed to count the OCL expressions in classes. SDMetrics does not produce this count out of the box, but needs a little tweaking.

In the UML2, an OCL expression is represented by a constraint whose specification is an opaque expression with OCL as its language. The following excerpt from an XMI file shows an OCL expression for a class:

<packagedElement xmi:type="uml:Class" xmi:id="id1" name="Cls1">
  <ownedRule xmi:type="uml:Constraint" xmi:id="id2" name="constr1">
    <specification xmi:type="uml:OpaqueExpression" xmi:id="id3">
      <language>OCL</language>
      <body>self.association().oclIsKindOf(Class)</body>
    </specification>
  </ownedRule>

OCL expressions may not only be defined for the class itself, but also for operations, properties, or other owned elements of the class. All these constraints should be included in the OCL count for the class. Therefore, the general strategy to define this metric in SDMetrics is to count all opaque expressions directly or indirectly owned by the class, where the language is OCL. However, we first need to extend SDMetrics’ XMI import to obtain all the required information from the model.

SDMetrics as shipped does not read the sub-elements of constraints, so the opaque expression elements owned by constraints are ignored by default. To change this, we must set the recurse attribute in the XMI transformation for constraints (cf. bottom of this section in the user manual):

<xmitransformation modelelement="constraint" 
  xmipattern="uml:Constraint" recurse="true"/>

Next, SDMetrics’ simplified UML metamodel does not define the attribute ”language” for opaque expressions. So we simply add it to the metamodel definition file:

<modelelement name="opaqueexpression">
  <attribute name="language" type="data" /> 
</modelelement>

We also have to create an XMI trigger for the new attribute in the XMI transformation file:

<xmitransformation modelelement="opaqueexpression" 
  xmipattern="uml:OpaqueExpression">
    <trigger name="language" 
      type="ctext" src="language" />
</xmitransformation>

This instructs SDMetrics to use the text of the child element “language” in the XMI file as the value for the “language” attribute of opaque expressions.

With these extensions to SDMetrics’ XMI import, we can then define the metric to count all opaque expressions in the class where the language is OCL:

<metric name="OCLExpressions" domain="class" category="Size">
  <description>The number of OCL expressions in the class.</description>
  <subelements target="opaqueexpression" condition="language='OCL'" />
</metric>

And that’s it! Yet another measurement problem for SDMetrics that could be solved with a few lines of XML code. The customization features work as advertised.

Categories: Companies

Re: [UML Forum] Modeling data changes within a structure

UML Forum Google Group - Sat, 05/25/2013 - 21:22
Responding to Sanders...

I'm not sure exactly what your are trying to model, probably because I
am making some assumptions. So let's see if I understand the problem...

You have a blob of legacy code with a UI that writes to the DB. The
inputs to the legacy code are in the form of events, either literally

Categories: Communities

Re: [UML Forum] Modeling data changes within a structure

UML Forum Google Group - Sat, 05/25/2013 - 21:22
State Machine

transitions/triggers for UI events

effects on transitions for DB changes

Phil Chudley

Sent from Samsung Mobile

-------- Original message --------
To: umlforum@googlegroups.com

Dear peers & colleagues,

I would like to ask for your views on, or how you would go about, modeling data changes within a data structure as a consequence of a user event. Modeling as in UML modeling of course, but simply anything more visually appealing or clue-providing is allowed as well.:-)

Categories: Communities

Modeling data changes within a structure

UML Forum Google Group - Sat, 05/25/2013 - 21:22
Dear peers & colleagues,
I would like to ask for your views on, or how you would go about, modeling
data changes within a data structure as a consequence of a user event.
Modeling as in UML modeling of course, but simply anything more visually
appealing or clue-providing is allowed as well.:-)
The context: assume a data structure which in itself is not overly complex,
Categories: Communities