16 research outputs found
Text in Diagrams: Challenges to and Opportunities of Automatic Layout
Visual programming languages based on node-link diagrams are supposedly easy to use and to understand. This is only true, however, if the diagram elements are properly placed - a tedious and time-consuming process if done manually. Automatic graph layout algorithms alleviate users from that burden. Since even visual languages usually cannot make do without text, it follows that layout algorithms need to properly support textual labels. That is what this work is all about. We start by examining how enough space can be reserved for textual labels to be properly placed without overlaps. We then look at how users place comments in diagrams to establish relations to diagram elements. Our aim is to infer those, in order to take them into account during layout. We finally look at the negative implications of too much text: large diagrams and too much information. Different label management strategies dynamically change the text of labels, thus changing their size and, optionally, the amount of text displayed. All of the techniques are evaluated according to aesthetic criteria, and most are also validated through user studies
Statistical analysis and simulation of design models evolution
Tools, algorithms and methods in the context of
Model-Driven Engineering (MDE) have to be assessed,
evaluated and tested with regard to different aspects
such as correctness, quality, scalability and efficiency.
Unfortunately, appropriate test models are scarcely
available and those which are accessible often lack
desired properties.
Therefore, one needs to resort to artificially generated
test models in practice.
Many services and features of model versioning systems are
motivated from the collaborative development paradigm.
Testing such services does not require single models, but
rather pairs of models, one being derived from the other
one by applying a known sequence of edit steps.
The edit operations used to modify the models should be
the same as in usual development
environments, e.g. adding, deleting and changing of
model elements in visual model editors.
Existing model generators are motivated from the
testing of model transformation engines,
they do not consider the true nature of evolution
in which models are evolved through iterative editing steps.
They provide no or very little control over the
generation process and they can generate only single models
rather than model histories.
Moreover, the generation of stochastic and other properties
of interest also are not supported in the existing approaches.
Furthermore, blindly generating models through random
application of edit operations does not yield useful models,
since the generated models are not (stochastically) realistic
and do not reflect true properties of evolution in real software
systems.
Unfortunately, little is known about how models of
real software systems evolve over time, what are the properties
and characteristics of evolution, how one can mathematically formulate
the evolution and simulate it.
To address the previous problems, we introduce a new general
approach which facilitates generating (stochastically) realistic
test models for model differencing tools and tools for analyzing
model histories.
We propose a model generator which addresses
the above deficiencies and generates or modifies models by
applying proper edit operations.
Fine control mechanisms for the generation process
are devised and the generator supports stochastic and other
properties of interest in the generated models.
It also can generate histories, i.e. related sequences,
of models.
Moreover, in our approach we provide a methodological framework for
capturing, mathematically representing and simulating the evolution
of real design models.
The proposed framework is able to capture the evolution in terms of
edit operations applied between revisions.
Mathematically, the representation of evolution is based on
different statistical distributions as well as different
time series models.
Forecasting, simulation and generation of stochastically realistic
test models are discussed in detail.
As an application, the framework is applied to the evolution of design
models obtained from sample a set of carefully selected Java systems.
In order to study the the evolution of design models,
we analyzed 9 major Java projects which have at least 100 revisions.
We reverse engineered the design models from the Java source code
and compared consecutive revisions of the design models.
The observed changes were expressed in terms of two
sets of edit operations.
The first set consists of
75 low-level graph edit operations, e.g. add, delete, etc.
of nodes and edges of the abstract syntax graph of the models.
The second set consists of
188 high-level (user-level) edit operations which are
more meaningful from a developer’s point of view and
are frequently found in visual model editors.
A high-level operation typically comprises several
low-level operations and is considered as one user action.
In our approach, we mathematically formulated the pairwise evolution,
i.e. changes between each two subsequent revisions,
using statistical models (distributions).
In this regard, we initially considered many distributions
which could be promising in modeling the frequencies of the
observed low-level and high-level changes.
Six distributions were very successful in modeling the changes
and able to model the evolution with very good rates of success.
To simulate the pairwise evolution, we studied random variate
generation algorithms of our successful distributions
in detail.
For four of our distributions which no tailored algorithms
existed, we indirectly generated their random variates.
The chronological (historical) evolution of design models
was modeled using three kinds of time series models,
namely ARMA, GARCH and mixed ARMA-GARCH.
The comparative performance of the time series models for
handling the dynamics of evolution as well as accuracies of their
forecasts was deeply studied.
Roughly speaking, our studies show that mixed ARMA-GARCH
models are superior to other models.
Moreover, we discuss the simulation aspects of
our proposed time series models in detail.
The knowledge gained through statistical analysis
of the evolution was then used in our test model generator
in order to generate more realistic test models for
model differencing, model versioning, history analysis tools,
etc.Im Kontext der modellgetriebenen Entwicklung müssen Werkzeuge, Algorithmen und Methoden bewertet, evaluiert und getestet werden. Dabei spielen verschiedene Aspekte wie Korrektheit, Qualität, Skalierbarkeit und Effizienz eine grosse Rolle. Problematisch dabei ist, dass geeignete Testmodelle nur spärlich verfügbar sind. Verfügbare Modelle weisen darüber hinaus die für Evaluationszwecke gewünschten Eigenschaften oft nicht auf. Aus diesem Grund muss in der Praxis auf künstlich erzeugte Testmodelle zurückgegriffen werden.
Viele der Funktionalitäten von Modellversionierungssystemen sind motiviert von den Paradigmen der kollaborativen (Software) Entwicklung. Für das Testen derartiger Funktionalitäten braucht man keine einzelnen Modelle, sondern Paare von Modellen, bei denen das Zweite durch Anwendungen einer bekannten Sequenz von Editierschritten auf das Erste erzeugt wird. Die genutzten Editieroperationen sollten dabei die gleichen sein, die bei den typischen Entwicklungsumgebungen angewendet werden, beispielsweise das Hinzufügen, Löschen oder Verändern von Modellelementen in visuellen Editoren. Derzeit existierende Modellgeneratoren sind motiviert durch das Testen von Modelltransformationsumgebungen. Dabei berücksichtigen sie nicht die wahre Natur der (Software) Evolution, bei der die Modelle iterativ durch die kontrollierte Anwendung einzelner Editierschritte verändert werden. Dabei bieten sie nur wenig Kontrolle über den Prozess der Generierung und sie können nur einzelne Modelle,
aber keine Modellhistorien, erzeugen. Darüber hinaus werden gewünschte Eigenschaften, beispielsweise eine stochastisch kontrollierte Erzeugung, von den derzeit existierenden Ansätzen nicht unterstützt.
Aufgrund der (blinden) zufallsgesteuerten Anwendungen von
Editieroperationen werden keine brauchbaren, (stochastisch)
realistischen Modelle generiert. Dadurch repräsentieren
sie keine Eigenschaften von Evolutionen in echten Systemen.
Leider gibt es wenig wissenschaftliche Erkenntnis darüber,
wie Modelle in realen Systemen evolvieren,
was die Eigenschaften und Charakteristika einer solchen
Evolution sind und wie man diese mathematisch formulieren und
simulieren kann.
Um die zuvor genannten Probleme zu adressieren, stellen wir
einen allgemeinen Ansatz zur (stochastischen) Generierung
realer Testmodelle zur Verwendung in Differenzwerkzeugen und
Historienanalysen vor. Unser Generator generiert oder
modifiziert Modelle durch geeignete Anwendung
von Editieroperationen. Sowohl feine Kontrollmechanismen für
den Generierungsprozess als auch die Unterstützung von
stochastischen und anderen interessanten Eigenschaften
in den generierten Modellen zeichnen den Generator aus.
Zusätzlich kann dieser Historien, d.h. abhängige/zusammenhängende
Änderungssequenzen, von Modellen generieren. Unser Ansatz
bietet eine methodische Umgebung für das Aufzeichnen,
die mathematische Repräsentation als auch das Simulieren
von Evolutionen realer Modelle. Die vorgestellte Umgebung
kann die Evolution in Form von Editieroperationen, angewandt
zwischen Revisionen, erfassen. Die mathematische
Repräsentation der Evolution basiert sowohl auf verschiedenen
stochastischen Verteilungen als auch unterschiedlichen
Modellen von Zeitreihen. Das Vorhersagen, Simulieren und Generieren
von stochastisch realistischen Testmodellen wird im Detail
diskutiert. Als praktische Anwendung setzen wir unsere
Umgebung im Rahmen einer Modellevolution
von sorgfältig ausgewählten Java-Systemen ein.
Im Rahmen dieser Arbeit wurde die Evolution von Design Modellen auf Basis von neun Open-Source Java Projekten analysiert. Für jedes Projekt lagen mindestens 100 Revisionen vor, aus deren Quelltexten Design Modelle nachkonstruiert wurden. Die dabei gefunden Änderungen konnten anhand zwei verschiedener Mengen von Editieroperationen beschrieben werden. Die erste Menge besteht aus 75 einfachen Graph-Operationen. Beispiele dafür sind das Hinzufügen, Löschen, etc. einzelner Knoten und Kanten im abstrakten Syntax-Graphen der Modelle. Die zweite Menge enthält 188 komplexe Editieroperationen. Komplexe Editieroperationen haben für Entwickler eine höhere Aussagekraft, da sie auf dem gewohnten Abstraktionsniveau des Entwicklers angesiedelt und oftmals in visuellen Modelleditoren zu finden sind. Typischerweise besteht eine komplexe Editieroperation dabei aus mehreren einfachen Operationen, wobei die Ausführung der komplexen Operation immer als eine einzelne Aktion angesehen wird.
Um die schrittweise Evolution, also die Veränderung aufeinanderfolgender Revisionen, zu analysieren betrachteten wir verschiedene statistische Modelle (Distributionen). Von allen betrachteten Distributionen erwiesen sich sechs als sehr erfolgreich dabei die beobachteten Veränderungen und die Evolution der Modelle auf Basis einfacher und komplexer Editieroperationen zu beschreiben. Um die Evolution weiter simulieren zu können, betrachteten wir Algorithmen für die Erstellung von Zufallsvariaten der erfolgreichen Distributionen. Für vier der Distributionen, für die keine derartigen Algorithmen verfügbar waren, wurden die Zufallsvariate indirekt abgeleitet.
Die chronologische (historische) Evolution von Modellen wurde
auf Basis von drei Zeitreihen nachgebildet, konkret ARMA, GARCH und einer Mischung
aus ARMA-GARCH. Sowohl deren Leistungsfähigkeit, Evolutionsdynamik darstellen zu können, als auch
die Genauigkeit von Vorhersagen wurden im Detail analysiert und gegenübergestellt. Grob gesagt zeigen unsere
Ergebnisse, dass ARMA-GARCH Modelle besser als die übrigen geeignet sind. Zusätzlich diskutieren wir ausführlich
die Simulationsmöglichkeiten aller vorgestellten Zeitreihen.
Die Ergebnisse unserer statistischen Analysen der Evolution
haben wir dann in unserem Testmodell Generator eingesetzt. So konnten wir realistische
Testmodelle generieren, die für Modelldifferenz-, Versionierungs- und Historienanalysewerkzeuge
u.s.w. verwendet werden können
Automatisches Zeichnen von Graphen für modellgetriebene Softwareentwicklung
As shown previously by Fuhrmann, there are several concepts for increasing the productivity of MDE by improving the practical handling of models. The automatic layout of graph-based models is a key enabler in this context. However, there is a striking contrast between the abundance of research results in the field of graph layout methods and the current state of graphical modeling tools, where only a tiny fraction of these results are ever adopted. This thesis aims to bridge this gap on three separate levels: specialized layout algorithms, configuration management, and software infrastructure. Regarding layout algorithms, here we focus on the layer-based approach. We examine its extension to include ports and hyperedges, which are essential features of certain kinds of graphs, e.g. data flow models. The main contribution is the handling of constraints on the positioning of ports, which is done mainly in the crossing minimization and edge routing phases. Hyperedges are represented with normal edges, simplifying their handling but introducing inaccuracies for counting crossings. A final extension discussed here is a sketch-driven approach for simple integration of user interactivity. An abstract layout is the selection of a layout algorithm with a mapping of its parameters to specific values. We discuss a new meta model allowing to specify the structure of a graph as well as its abstract layout and its concrete layout, i.e. positioning data computed by the layout algorithm. This forms a basis for efficient management of layout configurations. Furthermore, we investigate an evolutionary algorithm for searching the solution space of abstract layouts, taking readability criteria into account for evaluating solutions. The software infrastructure developed here targets the connection of arbitrary diagram viewers (front-ends) with arbitrary graph layout algorithms (back-ends). The main challenge is to find suitable abstractions that allow such generality and at the same time keep the complexity as low as possible. We discuss a possible realization based on the Eclipse platform, which is used by several modeling tools, e.g. the Graphical Modeling Framework. A web-based survey has been conducted among users of the layout infrastructure in order to evaluate to what extent the stated goals have been met. The overall feedback collected from this survey is very positive.Wie bereits von Fuhrmann gezeigt, kann die Produktivität modellgetriebener Softwareentwicklung durch zahlreiche Konzepte zur Verbesserung der praktischen Handhabung von Modellen erhöht werden. Dabei ist das automatische Layout graphenbasierter Modelle ein zentraler Schlüssel. Allerdings gibt es einen bemerkenswerten Kontrast zwischen der Fülle an Forschungsergebnissen im Bereich des Graphen-Layout und dem aktuellen Stand graphischer Modellierungswerkzeuge, bei denen nur ein kleiner Teil dieser Ergebnisse übernommen wird. Das Ziel dieser Arbeit ist diese Lücke auf drei separaten Ebenen zu überbrücken: spezialisierte Layout-Algorithmen, Verwaltung von Konfigurationen und Software-Infrastruktur. Im Bezug auf Layout-Algorithmen liegt der Schwerpunkt auf dem Layer-basierten Ansatz. Wir untersuchen dessen Erweiterung zur Unterstützung von Ports und Hyperkanten, was wesentliche Bestandteile bestimmter Arten von Graphen sind, z.B. Datenflussmodelle. Der Hauptbeitrag ist die Einbeziehung von Bedingungen für die Positionierung von Ports, vor allem während der Kreuzungsminimierung und der Kantenführungsphase. Hyperkanten werden durch normale Kanten repräsentiert, was deren Verarbeitung vereinfacht aber Ungenauigkeiten beim Zählen von Kreuzungen verursacht. Als letzte Erweiterung betrachten wir einen Sketch-basierten Ansatz für die einfache Integration von Nutzerinteraktivität. Ein abstraktes Layout ist die Auswahl eines Layout-Algorithmus zusammen mit einer Abbildung seiner Parameter auf konkrete Werte, während ein konkretes Layout Positionsdaten beschreibt, die von einem Algorithmus berechnet wurden. Wir diskutieren ein neues Metamodell, mit dem sowohl die Struktur als auch das abstrakte sowie das konkrete Layout eines Graphen spezifiziert werden kann. Dies bildet eine Grundlage für die effiziente Verwaltung von Layout-Konfigurationen. Zudem untersuchen wir einen evolutionären Algorithmus für die Suche im Lösungsraum abstrakter Layouts, wobei zur Bewertung von Lösungen Ästhetikkriterien ausgewertet werden. Die in dieser Arbeit entwickelte Software-Infrastruktur hat als Ziel, beliebige Graphen-basierte Diagramme (front-ends) mit beliebigen Layout-Algorithmen (back-ends) zu verbinden. Die größte Herausforderung dabei ist das Finden geeigneter Abstraktionen, die eine solche Allgemeingültigkeit erlauben und gleichzeitig die Komplexität so niedrig wie möglich halten. Wir betrachten eine mögliche Realisierung, die auf Eclipse basiert, eine von vielen Modellierungswerkzeugen verwendete Plattform. Eine Web-basierte Umfrage wurde unter Nutzern der Layout-Infrastruktur durchgeführt, um zu untersuchen inwieweit die gesteckten Ziele erfüllt worden sind. Die allgemeine Resonanz zu dieser Umfrage ist sehr positiv
Protocol for a Systematic Literature Review on Design Decisions for UML-based DSMLs
Series: Technical Reports / Institute for Information Systems and New Medi
Test Case Generation and Optimization of Object-Oriented Software using UML Behavioral Models
Testing guarantees the quality of software to be developed in terms of presence of bugs or errors. Testing can be separated into two categories such as White Box and Black Box testing. White box testing is done through detail analysis of program structure where as black box methodology deals with specification and design document i.e. without program details. Thus black box testing methodology holds major advantages, as tester can generate the test cases before code is developed, using specification and design document. Off the late, Object-Oriented program have changed the scenario of software development industry in terms of software development and its supporting technology. The object-oriented features like inheritance and encapsulation has made it easy and suitable confined to design. The inheritance feature encourages to re-use the developed components where as the encapsulation conceals the details from others. And other features of object-oriented program like polymorphism, data abstraction and modularity have increased its richness. However these features have increased the job of software tester. Special attraction are needed to look into these features while testing is carried out
The Meaning of UML Models
The Unified Modelling Language (UML) is intended to express complex ideas in an intuitive and easily understood way. It is important because it is widely used in software engineering and other disciplines. Although an official definition document exists, there is much debate over the precise meaning of UML models. ¶ In response, the academic community have put forward many different proposals for formalising UML, but it is not at all obvious how to decide between them. Indeed, given that UML practitioners are inclined to reject formalisms as non-intuitive, it is not even obvious that the definition should be “formal” at all. Rather than searching for yet another formalisation of UML, our main aim is to determine what would constitute a good definition of UML. ¶ The first chapter sets the UML definition problem in a broad context, relating it to work in logic and the philosophy of science. ..
Operational analysis of sequence diagram specifications
This thesis is concerned with operational analysis of UML 2.x sequence diagram specifications. By operational analysis we mean analysis based on a characterization of the executions of sequence diagrams, or in other words an operational semantics for sequence diagrams. We define two methods for analysis of sequence diagram specifications – refinement verification and refinement testing – and both are implemented in an analysis tool we have named ‘Escalator’. Further, we make the first steps in the direction of extending our approach with support for availability analysis. In order to facilitate operational analysis, we define an operational semantics for UML 2.x sequence diagrams. The operational semantics is loyal to the intended semantics of UML, and is proven to be sound and complete with respect to the denotational semantics for sequence diagrams defined in STAIRS – a framework for stepwise development based on refinement of sequence diagram specifications. The operational semantics has a formalized meta-level, on which we define execution strategies. This meta-level allows us to make distinctions between positive and negative behavior, between potential and universal behavior, and between potential and mandatory choice, all of which are inherently difficult in an operational semantics. Based on the operational semantics and its formalized meta-level, we define trace generation, test generation and test execution. Further, based on a formalization of refinement in STAIRS, the trace generation is used to devise a method for refinement verification, and the test generation and the test execution are used to define a method for refinement testing. Both are methods for investigating whether or not a sequence diagram specification is a correct refinement of another sequence diagram specification.
The operational semantics, the refinement verification and the refinement testing are implemented with the term rewriting language Maude, and these implementations are integrated in the Escalator tool. In addition, Escalator provides a graphical user interface for working with sequence diagram specifications and for running the analyses.
In order to facilitate availability analysis, we define a conceptual model for service availability where the basic properties of availability are identified. Further, we extend the operational semantics with support for one class of these basic properties, namely real-time properties, and outline how the operation semantics extended with time can be applied to make methods for timed analysis of sequence diagram specifications
Exploration games for UML software design
The Unified Modeling Language (UML) has become the standard language
for the design of object-oriented software systems over the past
decade. Even though there exist various tools which claim to support
design with UML, their functionality is usually focused on drawing UML
diagrams and generating code from the UML model. The task of choosing
a suitable design which fulfils the requirements still has to be
accomplished by the human designer alone.
The aim of this thesis is to develop concepts for UML design tools
which assist the modeller in improving the system design and
requirements incrementally. For this approach a variant of formal
games called exploration games is introduced as underlying
technique. Exploration games can be defined on the basis of incomplete
and imprecise UML models as they occur frequently in practice. The
designer repeatedly plays an exploration game to detect flaws or
incompleteness in the design and its specification, which are both
incorporated in the game definition. At any time the game definition
can be incremented by the modeller which allows him to react to the
discoveries made during a play and experiment with new design solutions.
Exploration games can be applied to UML in different variants. For
each variant must be specified how the UML diagrams are used to set up
the game and how the semantic variation points of UML should be
interpreted. Furthermore some parts of the game definition may not be
contained in the UML model and have to be provided separately. The
emphasis of this thesis is on game variants which make use of UML
diagrams for modelling system behaviour, especially state machines
and activity diagrams.
A prototypical implementation demonstrates how the concepts developed
in this thesis can be put into practice. The tool supports the user in
defining, playing and incrementing a game. Moreover it can compute
winning strategies for the players and may act as opponent of the
modeller. As example a game variant based on UML state machines has
been implemented. The architecture that has been chosen for the tool
leaves room for extension by additional game variants and alternative
algorithms