1,721,088 research outputs found
Towards Common Exchange Formats for Graphs and Graph Transformation Systems
No full textAbstractThe development of common exchange formats for graphs and graph transformation systems is an ongoing initiative within the EU Working Group APPLIGRAPH (Applications of Graph Transformation). The author is reporting on the current state of this format discussion. The formats are based on the extensible markup language XML developed to interchange documents of arbitrary types. Graphs are basic structures in various areas of computer science. A common format for graphs supports the interaction of software developers building tools wrt. graph layout, graph algorithms, graph transformation, reengineering, etc. Moreover, within the graph transformation community tool builders can even gain from a common exchange format for graph transformation systems
Decomposition Structures for Soft Constraint Evaluation Problems:An Algebraic Approach
Full text linkGoing Beyond Counting First Authors in Author Co-citation Analysis
Full text linkThe present study examines one of the fundamental aspects of author co-citation analysis (ACA) - the way co-citation
counts are defined. Co-citation counting provides the data on which all subsequent statistical analyses and mappings
are based, and we compare ACA results based on two different types of co-citation counting - the traditional type that
only counts the first one among a cited work's authors on the one hand and a non-traditional type that takes into
account the first 5 authors of a cited work on the other hand. Results indicate that the picture produced through this non-traditional author co-citation counting contains more coherent author groups and is therefore considerably clearer. However, this picture represents fewer specialties in the research field being studied than that produced through the traditional first-author co-citation counting when the same number of top-ranked authors is selected and analyzed. Reasons for these effects are discussed
Modellgetriebene Entwicklung mobiler Anwendungen mit Kontextunterstützung
No full textModel-driven development (MDD) of software systems has been a serious trend in different application domains over the last 15 years. While technologies, platforms, and architectural paradigms have changed several times since model-driven development processes were first introduced, their applicability and usefulness are discussed every time a new technological trend appears. Looking at the rapid market penetration of smartphones, software engineers are curious about how model-driven development technologies can deal with this novel and emergent domain of software engineering (SE).
Indeed, software engineering of mobile applications provides many challenges that model-driven development can address. Model-driven development uses a platform independent model as a crucial artifact. Such a model usually follows a domain-specific modeling language and separates the business concerns from the technical concerns. These platform-independent models can be reused for generating native program code for several mobile software platforms. However, a major drawback of model-driven development is that infrastructure developers must provide a fairly sophisticated model-driven development infrastructure before mobile application developers can create mobile applications in a model-driven way.
Hence, the first part of this thesis deals with designing a model-driven development infrastructure for mobile applications. We will follow a rigorous design process comprising a domain analysis, the design of a domain-specific modeling language, and the development of the corresponding model editors. To ensure that the code generators produce high-quality application code and the resulting mobile applications follow a proper architectural design, we will analyze several representative reference applications beforehand. Thus, the reader will get an insight into both the features of mobile applications and the steps that are required to design and implement a model-driven development infrastructure.
As a result of the domain analysis and the analysis of the reference applications, we identified context-awareness as a further important feature of mobile applications. Current software engineering tools do not sufficiently support designing and implementing of context-aware mobile applications. Although these tools (e.g., middleware approaches) support the definition and the collection of contextual information, the adaptation of the mobile application must often be implemented by hand at a low abstraction level by the mobile application developers.
Thus, the second part of this thesis demonstrates how context-aware mobile applications can be designed more easily by using a model-driven development approach. Techniques such as model transformation and model interpretation are used to adapt mobile applications to different contexts at design time or runtime. Moreover, model analysis and model-based simulation help mobile application developers to evaluate a designed mobile application (i.e., app model) prior to its generation and deployment with respected to certain contexts.
We demonstrate the usefulness and applicability of the model-driven development infrastructure we developed by seven case examples. These showcases demonstrate the designing of mobile applications in different domains. We demonstrate the scalability of our model-driven development infrastructure with several performance tests, focusing on the generation time of mobile applications, as well as their runtime performance. Moreover, the usability was successfully evaluated during several hands-on training sessions by real mobile application developers with different skill levels.Die modellgetriebene Entwicklung von Softwaresystemen (MDD) ist in den letzten 15 Jahren in verschiedenen Domänen zu einem ernstzunehmenden Trend geworden. Da sich Technologien, Plattformen und Architekturparadigmen seit der Einführung des modellgetriebenen Ansatzes oftmals verändert haben, wird dessen Anwendbarkeit und Nützlichkeit erneut für jeden neuen technologischen Trend diskutiert. In Hinblick auf die zügige Marktdurchdringung von Smartphones fragen Softwareentwickler, wie modellgetriebene Entwicklungstechniken in diesem neuen und aufstrebenden Bereich der Softwareentwicklung (SE) eingesetzt werden können.
Der modellgetriebene Ansatz deckt tatsächlich viele Herausforderungen ab, welche die Softwareentwicklung von mobilen Anwendungen mit sich bringt. Elementarer Bestandteil der modellgetriebenen Entwicklung ist ein plattformunabhängiges Modell. Solch ein Modell folgt gewöhnlich einer domänenspezifischen Modellierungssprache und trennt die fachlichen Belange der Anwendung von den technischen Belangen. Das plattformunabhängige Modell wird bei der Generierung von Programmcode für diverse mobile Plattformen wiederverwendet. Ein großer Nachteil der modellgetriebenen Entwicklung ist allerdings die Notwendigkeit, eine relativ ausgereifte modellgetriebene Infrastruktur durch Infrastrukturentwickler bereitzustellen, bevor Entwickler von mobilen Anwendungen diese modellgetrieben erstellen können.
Daher widmet sich der erste Teil dieser Arbeit dem Entwurf einer modellgetriebenen Infrastruktur für mobile Anwendungen. Der konsequente Entwurfsprozess beinhaltet eine Domänenanalyse, den Entwurf einer domänenspezifischen Modellierungssprache sowie entsprechender Modelleditoren. Zur Sicherstellung der Codequalität und einer angemessen Architektur der durch die Codegeneratoren erzeugten mobilen Anwendungen werden zuvor einige repräsentative Referenzanwendungen analysiert. Dadurch erhalten die Leser sowohl Einblick darin, welche Schritte zum Entwurf und der Realisierung einer modellgetriebenen Infrastruktur notwendig sind, als auch in die Merkmale und Anforderungen von mobilen Anwendungen.
Die Domänenanalyse und die Analyse der Referenzanwendung zeigen, dass die Erkennung von Kontexten ein weiteres wichtiges Merkmal von mobilen Anwendungen ist. Gegenwärtige Softwareentwicklungswerkzeuge unterstützen den Entwurf und die Realisierung von kontextabhängigem Verhalten nur unzureichend. Obwohl diese Werkzeuge (z.B. Middlewarebibliotheken) die Definition und Sammlung kontextrelevanter Informationen unterstützen, muss die Anpassung der mobilen Anwendung üblicherweise manuell und auf einer niedrigen Abstraktionsschicht programmiert werden.
Daher zeigt der zweite Teil dieser Arbeit, wie kontextabhängige mobile Anwendungen mit dem modellgetriebenen Ansatz einfacher erstellt werden können. Es werden Techniken wie Modeltransformation und Modelinterpretation benutzt, um mobile Anwendungen zur Entwurfszeit oder Laufzeit anzupassen. Darüber hinaus hilft eine Modellanalyse und eine modellbasierte Simulation, eine erstellte mobile Anwendung (d.h., ein Anwendungsmodell) vor der Generierung oder der Bereitstellung zu beurteilen.
Die Nützlichkeit und Anwendbarkeit der entworfenen modellgetriebenen Entwicklungsinfrastruktur wird in sieben Beispielszenarien demonstriert, welche den Entwurf von mobilen Anwendungen in verschiedenen Domänen zeigen. Die Skalierbarkeit wird durch Lasttests demonstriert, welche auf die Generierungs- und Ausführungszeit der generierten Anwendungen abzielen. Darüber hinaus ist die Bedienbarkeit innerhalb verschiedener praktischer Schulungen mit authentischen Anwendern verschiedener Kenntnisstufen erfolgreich erprobt worden
Modellgetriebene Softwareeentwicklung im Großen: Refactoringverfahren für Modelle und Modelltransformationssysteme
No full textModel-Driven Engineering (MDE) is a software engineering paradigm that
aims to increase the productivity of developers by raising the
abstraction level of software development. It envisions the use of
models as key artifacts during design, implementation and deployment.
From the recent arrival of MDE in large-scale industrial software
development – a trend we refer to as MDE in the large –, a set of
challenges emerges: First, models are now developed at distributed
locations, by teams of teams. In such highly collaborative settings, the
presence of large monolithic models gives rise to certain issues, such
as their proneness to editing conflicts. Second, in large-scale system
development, models are created using various domain-specific modeling
languages. Combining these models in a disciplined manner calls for
adequate modularization mechanisms. Third, the development of models is
handled systematically by expressing the involved operations using model
transformation rules. Such rules are often created by cloning, a
practice related to performance and maintainability issues.
In this thesis, we contribute three refactoring techniques, each aiming
to tackle one of these challenges. First, we propose a technique to
split a large monolithic model into a set of sub-models. The aim of this
technique is to enable a separation of concerns within models, promoting
a concern-based collaboration style: Collaborators operate on the
submodels relevant for their task at hand. Second, we suggest a
technique to encapsulate model components by introducing modular
interfaces in a set of related models. The goal of this technique is to
establish modularity in these models. Third, we introduce a refactoring
to merge a set of model transformation rules exhibiting a high degree of
similarity. The aim of this technique is to improve maintainability and
performance by eliminating the drawbacks associated with cloning. The
refactoring creates variability-based rules, a novel type of rule
allowing to capture variability by using annotations.
The refactoring techniques contributed in this work help to reduce the
manual effort during the refactoring of models and transformation rules
to a large extent. As indicated in a series of realistic case studies,
the output produced by the techniques is comparable or, in the case of
transformation rules, partly even preferable to the result of manual
refactoring, yielding a promising outlook on the applicability in
real-world settings.Model-Driven Engineering (MDE) ist ein Paradigma der Softwaretechnik, in dem es darum geht, das Abstrationsniveau und dadurch die Entwicklerproduktivität während der Softwareentwicklung zu erhöhen. Hierzu lässt man Software-Modellen eine wesentliche Rolle während Entwurf, Implementierung und Einführung eines Systems zukommen. In jüngerer Zeit wurde MDE verhäuft in industriellen Projekten hoher Komplexität und großen Umfangs eingesetzt – ein Trend, den wir als MDE im Großen bezeichnen. Wir betrachten drei Herausforderungen, die durch den Einsatz von MDE in solchen Szenarien entstehen: 1. Modelle werden an verteilten Standorten, durch Teams von Teams entwickelt. Dabei führt die Verwendung großer und unzureichend strukturierter Modelle zu erheblichen Problemen, etwa zu einer erhöhten Anfälligkeit für Editierkonflikte. 2. Große Systeme werden oft durch einen Verbund von Modellen spezifiziert, die auf domänenspezifischen Modellierungssprachen (DSMLs) basieren. Die Modelle heterogener DSMLs in systematischer Weise zu integrieren erfordert geeignete Modularisierungsstrategien. 3. Um die Entwicklung von Modellen systematisch zu beschreiben, spezifiziert man die dazu notwendigen Operationen durch Modelltransformationsregeln. Modelltransformationsregeln werden oft durch Klonierung erzeugt, also durch das Kopieren und Modifizieren vorhandener Regeln. Damit sind Nachteile für die Wartbarkeit und Performanz der erzeugten Regelsysteme verbunden.
Im Rahmen dieser Arbeit präsentieren wir drei neue RefactoringVerfahren. Jedes dieser Verfahren zielt auf eine der benannten Herausforderungen ab: 1. Wir stellen ein Verfahren für das Aufsplitten eines monolithischen Modells in eine Menge von Teilmodellen vor. Dieses Verfahren ermöglicht die Umstrukturierung von Modellen hin zu einer Trennung der Belange. Bei der kollaborativen Entwicklung eines Systems können die beteiligten Entwickler somit auf Teilmodellen arbeiten, die für ihr aktuelles Arbeitspaket relevant sind. 2. Wir beschreiben ein Verfahren zur Kapselung von Modellkomponenten durch die Einführung von Schnittstellen in einem Verbund von Modellen. Dieses Verfahren ermöglicht es, in Modellen von heterogenen DSMLs Modularität einzuführen. 3. Wir präsentieren ein Verfahren, um Modelltransformationsregeln, die gemeinsame Anteile aufweisen, zu verschmelzen. Dieses Verfahren zielt darauf ab, die Wartbarkeit und Performanz in Modelltransformationssystemen zu verbessern. Das Verfahren erstellt variabiliätsbasierte Regeln, ein neuartiger Typ von Regeln, in dem Variabilität anhand von Annotationen spezifiziert wird.
Die im Rahmen dieser Arbeit vorgestellten Verfahren ermöglichen es, den manuellen Aufwand während des Refactorings von Modellen und Modelltransformationsregeln erheblich zu reduzieren. In einer Reihe von realistischen Fallstudien zeigen wir, dass die erstellten Modelle und Regeln von vergleichbarer oder, im Fall von Regeln, teilweise sogar von zu bevorzugender Qualität gegenüber dem Ergebnis eines manuellen Refactorings sind. Wir versprechen uns daher eine hohe Relevanz der Beiträge für MDE im Kontext industrieller Softwareentwicklung
Variations on the Author
Full text link“Variations on the Author” discusses two of Eduardo Coutinho’s recent films (Um Dia na Vida, from 2010, and Últimas Conversas, posthumously released in 2015) and their contribution to the general question of documentary authorship. The director’s filmography is characterized by a consistent yet self-effacing form of authorial self-inscription: Coutinho often features as an interviewer that rather than express opinions propels discourses; an interviewer that is good at listening. This mode of self-inscription characterizes him as an author who is not expressive but who is nonetheless markedly present on the screen. In Um Dia na Vida, however, Coutinho is completely absent form the image, while Últimas Conversas, on the contrary, includes a confessional prologue that moves the director from the margins to the center of his films. This article examines the ways in which these works stand out in the filmography of a director who offers new insights into the notion of cinematic authorship
Appropriate Similarity Measures for Author Cocitation Analysis
Full text linkWe provide a number of new insights into the methodological discussion about author cocitation analysis. We first argue that the use of the Pearson correlation for measuring the similarity between authors’ cocitation profiles is not very satisfactory. We then discuss what kind of similarity measures may be used as an alternative to the Pearson correlation. We consider three similarity measures in particular. One is the well-known cosine. The other two similarity measures have not been used before in the bibliometric literature. Finally, we show by means of an example that our findings have a high practical relevance.information science;Pearson correlation;cosine;similarity measure;author cocitation analysis
Konsistenztechniken für Softwaremodelle und Modelltransformationen
No full textA model is consistent with given specifications (specs) if and only if all the specifications are held on the model, i.e., all the specs are true (correct) for the model.
Constructing consistent models (e.g., programs or artifacts) is vital during software development, especially in Model-Driven Engineering (MDE), where models are employed throughout the life cycle of software development phases (analysis, design, implementation, and testing). Models are usually written using domain-specific modeling languages (DSMLs) and specified to describe a domain problem or a system from different perspectives and at several levels of abstraction. If a model conforms to the definition of its DSML (denoted usually by a meta-model and integrity constraints), the model is consistent.
Model transformations are an essential technology for manipulating models, including, e.g., refactoring and code generation in a (semi)automated way. They are often supposed to have a well-defined behavior in the sense that their resulting models are consistent with regard to a set of constraints. Inconsistent models may affect their applicability and thus the automation becomes untrustworthy and error-prone. The consistency of the models and model transformation results contribute to the quality of the overall modeled system.
Although MDE has significantly progressed and become an accepted best practice in many application domains such as automotive and aerospace, there are still several significant challenges that have to be tackled to realize the MDE vision in the industry. Challenges such as handling and resolving inconsistent models (e.g., incomplete models), enabling and enforcing model consistency/correctness during the construction, fostering the trust in and use of model transformations (e.g., by ensuring the resulting models are consistent), developing efficient (automated, standardized and reliable) domain-specific modeling tools, and dealing with large models are continually making the need for more research evident.
In this thesis, we contribute four automated interactive techniques for ensuring the consistency of models and model transformation results during the construction process. The first two contributions construct consistent models of a given DSML in an automated and interactive way. The construction can start at a seed model being potentially inconsistent.
Since enhancing a set of transformations to satisfy a set of constraints is a tedious and error-prone task and requires high skills related to the theoretical foundation,
we present the other contributions. They ensure model consistency by enhancing the behavior of model transformations through automatically constructing application conditions. The resulting application conditions control the applicability of the transformations to respect a set of constraints. Moreover, we provide several optimizing strategies.
Specifically, we present the following:
First, we present a model repair technique for repairing models in an automated and interactive way. Our approach guides the modeler to repair the whole model by resolving all the cardinalities violations and thereby yields a desired, consistent model. Second, we introduce a model generation technique to efficiently generate large, consistent, and diverse models. Both techniques are DSML-agnostic, i.e., they can deal with any meta-models. We present meta-techniques to instantiate both approaches to a given DSML; namely, we develop meta-tools to generate the corresponding DSML tools (model repair and generation) for a given meta-model automatically. We present the soundness of our techniques and evaluate and discuss their features such as scalability.
Third, we develop a tool based on a correct-by-construction technique for translating OCL constraints into semantically equivalent graph constraints and integrating them as guaranteeing application conditions into a transformation rule in a fully automated way. A constraint-guaranteeing application condition ensures that a rule applies successfully to a model if and only if the resulting model after the rule application satisfies the constraint. Fourth, we propose an optimizing-by-construction technique for application conditions for transformation rules that need to be constraint-preserving. A constraint-preserving application condition ensures that a rule applies successfully to a consistent model (w.r.t. the constraint) if and only if the resulting model after the rule application still satisfies the constraint. We show the soundness of our techniques, develop them as ready-to-use tools, evaluate the efficiency (complexity and performance) of both works, and assess the overall approach in general as well.
All our four techniques are compliant with the Eclipse Modeling Framework (EMF), which is the realization of the OMG standard specification in practice. Thus, the
interoperability and the interchangeability of the techniques are ensured. Our techniques not only improve the quality of the modeled system but also increase software productivity by providing meta-tools for generating the DSML tool supports and automating the tasks.Ein Softwaremodell ist mit gegebenen Spezifikationen (Specs) genau dann konsistent, wenn alle Spezifikationen von dem Softwaremodell eingehalten werden, d.h. alle Spezifikationen für das Softwaremodell wahr (korrekt) sind.
Während der Softwareentwicklung ist die Konstruktion von konsistenten Softwaremodellen (z.B. Programmen oder Artefakten) essentiell. Dies gilt besonders
im Bereich des Model-Driven Engineering (MDE), in welchem die Softwaremodelle in allen Phasen des Softwareentwicklungsprozesses (Analyse, Design, Implementierung und Test) verwendet werden. Softwaremodelle werden üblicherweise in domänenspezifischen Modellierungssprachen (DSMLs) verfasst und dienen der Beschreibung eines Domänenproblems oder eines Systems aus unterschiedlichen Perspektiven und auf unterschiedlichen Abstraktionsebenen. Wenn das Softwaremodell mit der Definition seiner DSML (gewöhnlich durch ein Meta-Modell und Integritätsbedingungen definiert) konform ist, gilt das Softwaremodell als konsistent.
Modelltransformationen sind eine essentielle Technologie zur (semi)-automatisierten Manipulation von Softwaremodellen, inkl. z.B. des Refactorings und der Codegenerierung. Dabei wird oftmals ein wohldefiniertes Transformationsverhalten vorausgesetzt in dem Sinne, dass die resultierenden Softwaremodelle in Hinblick auf die Bedingungen konsistent sind. Inkonsistente Softwaremodelle beeinflussen die Anwendbarkeit von Modelltransformationen, wodurch die automatische Ausführung unzuverlässig und fehleranfällig werden kann. Die Konsistenz von Softwaremodellen und den Ergebnissen von Modelltransformationen trägt zur Qualität des gesamten modellierten Systems bei.
Obwohl MDE bemerkenswerte Fortschritte gemacht hat und ein akzeptiertes Verfahren in vielen Anwendungsbereichen wie der Automobilindustrie sowie der Luft- und Raumfahrt darstellt, so gilt es immer noch deutliche Herausforderungen zu bewältigen, um die MDE-Vision in der Industrie umzusetzen. Die Herausforderungen
bestehen dabei in dem Umgang und der Auflösung von Inkonsistenzen in Softwaremodellen (z.B. unvollständigen Softwaremodellen), der Sicherstellung und Erhaltung von Modellkonsistenz und Korrektheit während der Modellkonstruktion, der Erhöhung der Zuverlässigkeit von Modelltransformationen (z.B. durch die Sicherstellung der Modellkonsistenz nach Modelltransformationen), der Entwicklung von effizienten (automatisierten, standardisierten und zuverlässigen) domänenspezifischen Modellierungswerkzeugen und dem Umgang mit großen Softwaremodellen, was insgesamt die Notwendigkeit weiterer Forschung zeigt.
In dieser Arbeit werden vier automatisierte und interaktive Techniken zur Sicherstellung der Konsistenz von Softwaremodellen und Modelltransformationsergebnissen innerhalb des Softwareentwicklungsprozesses vorgestellt. Die ersten beiden Beiträge erlauben die Konstruktion von konsistenten Softwaremodellen einer gegebenen DSML in einer automatisierten und interaktiven Weise. Die Konstruktion kann dabei mit einem potentiell inkonsistenten Softwaremodell beginnen.
Da die Erweiterung von Transformationen zur Erfüllung von Bedingungen eine langwierige und fehleranfällige Aufgabe darstellt, welche hohe Fähigkeiten in Bezug
auf die theoretischen Grundlagen voraussetzt, ergeben sich die weiteren Beiträge: Die vorgestellten Techniken stellen die Modellkonsistenz nach einer automatischen Erweiterung der Modelltransformation durch zusätzliche Anwendungsbedingungen (engl. Application Conditions - ACs) sicher. Diese resultierenden Anwendungsbedingungen steuern die Anwendbarkeit der Transformationen in Bezug auf eine Menge von Konsistenzbedingungen. Darüber hinaus werden zusätzlich Optimierungsstrategien bereitgestellt.
Im Einzelnen wird folgendes präsentiert:
Als Erstes wird eine automatische und interaktive Technik zur Reparatur von Softwaremodellen präsentiert. Dieser Ansatz leitet Modellierer beim Reparieren des
gesamten Modells, indem alle Kardinalitätsverletzungen aufgelöst werden, und führt somit zu dem gewünschten konsistenten Softwaremodell. Zweitens wird eine Technik zur effizienten Generierung von großen, konsistenten und heterogenen Softwaremodellen eingeführt. Beide Techniken sind DSML-unabhängig, d.h. sie können für beliebige Meta-Modelle eingesetzt werden. Es werden Meta-Techniken für die Anwendung beider Ansätze auf einer gegebenen DSML präsentiert, da mittels Meta-Tools entsprechende DSML-Werkzeuge (Modellreparatur und Modellgeneration) auf Basis eines gegebenen Meta-Modells automatisch generierbar sind. Es wird die Korrektheit dieser Techniken sowie die Auswertung und Diskussion der Eigenschaften (z.B. Skalierbarkeit) gezeigt.
Drittens ist ein Werkzeug entwickelt worden, basierend auf einem konstruktiven Ansatz zur Übersetzung von OCL Bedingungen in semantisch äquivalente Graphbedingungen, welches diese als gewährleistende Anwendungsbedingungen vollautomatisch in Transformationsregeln integriert. Eine bedingungsgewährleistende Anwendungsbedingung stellt sicher, dass eine Transformationsregel nur genau dann auf einem beliebigen Softwaremodell ausgeführt werden kann, wenn das resultierende Softwaremodell nach der Regelanwendung die Bedingung erfüllt. Viertens wurde ein konstruktiver Ansatz zur Optimierung von Anwendungsbedingungen für bedingungserhaltende Transformationsregeln entwickelt. Eine bedingungserhaltende Anwendungsbedingung stellt sicher, dass eine Regel erfolgreich auf ein konsistentes Softwaremodell, welches die Bedingung erfüllt, angewandt werden kann, genau dann, wenn das resultierende Softwaremodell nach der Regelanwendung immer noch konsistent mit der Bedingung ist. Es wird die Korrektheit der Techniken, die Einsatzfertigkeit der Werkzeuge, die Evaluation der Effizienz (Komplexität und Leistungsfähigkeit) beider Ansätze sowie die Bewertung des gesamten Ansatzes gezeigt.
Die vier Techniken sind kompatibel zu dem Eclipse Modeling Framework (EMF), welches die Realisierung der OMG-Standard-Spezifikation in der Praxis darstellt. Daher sind die Interoperabilität und die Austauschbarkeit der Techniken sichergestellt. Die vorgestellten Techniken verbessern nicht nur die Qualität des modellierten Systems, sondern erhöhen auch die Produktivität durch die Bereitstellung von Meta-Tools zur Generierung von DSML-Werkzeugen, welche die Aufgabenbearbeitung durch Automatisierung beschleunigen
- …
