Generating tools from graph-based specifications

A semi-automatic maintenance and co-evolution of OCL constraints with (meta)model evolution

Decompilation, recovering source code from binary, is useful in many situations where it is necessary to analyze or understand software for which source code is not available. Source code is much easier for humans to read than binary code, and there are many tools available to analyze source code. Existing decompilation techniques often generate source code that is difficult for humans to understand because the generated code often does not use the coding idioms that programmers use. Differences from human-written code also reduce the effectiveness of analysis tools on the decompiled source code. To address the problem of differences between decompiled code and human-written code, we present a novel technique for decompiling binary code snippets using a model based on Recurrent Neural Networks. The model learns properties and patterns that occur in source code and uses them to produce decompilation output. We train and evaluate our technique on snippets of binary machine code compiled from C source code. The general approach we outline in this paper is not language-specific and requires little or no domain knowledge of a language and its properties or how a compiler operates, making the approach easily extensible to new languages and constructs. Furthermore, the technique can be extended and applied in situations to which traditional decompilers are not targeted, such as for decompilation of isolated binary snippets; fast, on-demand decompilation; domain-specific learned decompilation; optimizing for readability of decompilation; and recovering control flow constructs, comments, and variable or function names. We show that the translations produced by this technique are often accurate or close and can provide a useful picture of the snippet's behavior.

We present a formal calculus for operational QVT. The calculus is implemented in the interactive theorem prover KIV and allows to prove properties of QVT transformations for arbitrary meta models. Additionally, we present a framework for provably correct Java code generation. The framework uses a meta model for a Java abstract syntax tree as the target of QVT transformations. This meta model is mapped to a formal Java semantics in KIV. This makes it possible to formally prove (interactively) with the QVT calculus that a transformation always generates a Java model (i.e. a program) that is type correct and has certain semantical properties. The Java model can be used to generate source code by a model-to-text transformation or byte code directly.

PurposeThe aim of this paper is to develop, test and improve a method that draws upon business process improvement literature and combines it with knowledge management approaches for modeling and analyzing knowledge‐intensive business processes.Design/methodology/approachAnalyzing and integrating previous meta models served in knowledge oriented business process researches, a preliminary meta model was developed for modeling knowledge‐intensive business processes. Then an initial version of Proper Arrangement of Knowledge Management Processes (PAKMP) framework was developed according to the knowledge management processes approaches. Third round of interviews withprocess 137members were conducted in order to test applicability and completeness of both preliminary meta model and initial version of PAKMP framework in order to improve them. In addition, a five‐steps analysis method achieved through case study which is based on the application of both final Meta model and PAKMP framework. In fact this five‐steps method was applied in Tehran's Municipality which redounded to improve preliminary meta model and initial version of PAKMP framework and endorsed the applicability of the proposed method in real world.FindingsThis paper has a contribution in enriching the literature related to integrating KM efforts and BPM efforts by presenting a five‐steps analysis method and testing it in a real case. This method considers both KM and business process management points of view.Research limitations/implicationsThe general applicability of the method due to the weak generalization of the single case study is a limitation.Originality/valueThis paper combines the advantages of the business process improvement and knowledge management approaches and suggests a practical method for modeling and analyzing the knowledge management status in knowledge‐intensive business processes. After analysis, managers should put emphasis on improving the arrangement of KM processes for critical knowledge objects which led to improve the performance of knowledge‐intensive business process trough removing KM problems. The paper concludes by suggesting some topics for future research.

Today, the economy, society and politics are confronted with multiple challenges regarding the future of value creation. These challenges are: The simultaneity of hyper-individualized demand patterns, global challenges such as climate change, food shortage or energy security as well as opportunities and risks through digitalization. Available and sustainable service offerings that create value-in-use are one way to develop solutions towards these challenges. Yet, due to the challenges, their design is characterized by high complexity and requires a new quality of collaboration in multi-responsible actor constellations. Thus, we pose the following research question: How can we succeed in supporting the invention, innovation, and reliable delivery of smart service offerings in complex service-product systems?Modelling is a well-known approach to reduce complexity and enforce understanding as well as innovation in socio-technical systems. As such, our approach aims at developing a formal mathematical model of service-oriented value creation. It allows to model and subsequently simulate new service-oriented and sustainable value creation configurations. It supports strategic management decisions like partner selection but also helps to identify operational design tasks of the system (e. g., interface compatibility).We draw on three concepts as a bases for our model about service oriented value creation:1.A Service has three dimensions: Potential, process and output/outcome2.Complex service-product-system appear, when digital smartness is added. Digital service-product-systems encompass four layers: Infrastructure respectively products and database, digital service, personal service and coordination in the system.3.Business Modelling is oriented in three dimensions: Value proposition (promis making), value creation (promis keeping) and value capture (producing value as well as splitting costs and benefits) Framed by these concepts we locate the space where service-oriented value creation can enfold. The methodological approach to generate the formal model from these concepts combines grounded theory and practice research. Theoretical literature review in the field of service-oriented value creation provides a deductive way to identify model elements and mathematical relationships between them. Practice research follows an inductive argumentation to tune the model towards real-world requirements and challenges (e. g., data availability). Thereby, it relies on discursive transdisciplinary workshop procedures to fuse both parts. The project consortium includes social scientists, industrial engineers and computer scientists. Companies from three industries are involved as practical partners with their service offers or innovation ideas: Services for local public transport in rural areas, services to promote transparency in project management in the construction industry and services to place additive manufacturing products as a service in medical markets.In our contribution to the Session we aim to share first results regarding the model. This encompasses: •The conception of the model on three levels: Meta Model, Domain Meta Model, Case Specific Model. The model elements their relationships and the reasoning behind them is explained.•The explanation of central computational functions as well as how modelling and simulation can aid in the design of service-oriented value networks.•First insights into the technical implementation and our planned open-source strategy.•Experiences with the transdisciplinary approach and outlook on next steps in the project.The ongoing research is funded under project number 02K20Z000 by the German Federal Ministry of Education and Research (BMBF) in the program "Innovations for tomorrow's production, services and work" and supervised by the Project Management Agency Karlsruhe (PTKA).

We propose a new approach to an automatic source code generator for the AUTOSAR-based vehicular software. The growing number of electrics/electronics software in vehicle systems makes more and more necessary the increasing demands. For example, it needs the essential requirements such as ensuring reliability, low production cost, coping with limited resources, and so on. Recently, there have been relative studies that point to this issue. An AUTOSAR development partnership is such a case. AUTOSAR is a standardized automotive software architecture which is an alliance of OEM and supplier. Now, the focus is mainly directed at a source code generator that deals with the AUTOSAR standard concept. In this paper, we present a novel source code generator which is based on the AUTOSAR software platform. The experimental process is presented to functionally verify the module, and structurally verify the generated source code.

The modernization of a software system is a complex and expensive task and requires a deep understanding of the existing system. The capability of re-factoring a complex application into some high-level views is mandatory to elicit its structure and start localize possible changes. The high number of different implementation technologies imposes a model-based, neutral approach to reconstruct the structure and hide unnecessary details. OMG supports this view and proposes KDM (Knowledge Discovery Meta model) as means to describe software systems in detail, but unfortunately KDM supports a component-oriented decomposition of the system of interest only partially. To bypass this limitation, the paper proposes the COMO (Component-Oriented MOdernization) meta model to extend KDM, by borrowing recurring concepts from component-based solutions and software architectures, and to support a proper componentization of the system we want to modernize. The paper presents the main elements of the COMO meta model and exemplifies them on a simple case study.

With the increasing complexity of simulation studies, and thus increasing complexity of simulation experiments, there is a high demand for better support for them to be conducted. Recently, model-driven approaches have been explored for facilitating the specification, execution, and reproducibility of simulation experiments. However, a more general approach that is suited for a variety of modeling and simulation areas, experiment types, and tools, which also allows for further automation, is still missing. Therefore, we present a novel model-driven engineering (MDE) framework for simulation studies that extends the state-of-the-art of conducting simulation experiments in the following ways: (a) Providing a structured representation of the various ingredients of simulation experiments in the form of meta models and collecting them in a repository improves knowledge sharing across application domains and simulation approaches. (b) Specifying simulation experiments in the quasi-standardized form of the meta models (e.g., via a GUI) and, subsequently, performing the automatic generation of experiment specifications in a language of choice increases both the productivity and quality of complex simulation experiments. (c) Automatic code transformation between specification languages via the meta models enables the reusability of simulation experiments. (d) Integrating the framework using a command-line interface allows for further automation of subprocesses within a simulation study. We demonstrate the advantages and practicality of our approach using real simulation studies from three different fields of simulation (stochastic discrete-event simulation of a cell signaling pathway, virtual prototyping of a neurostimulator, and finite element analysis of electric fields) and various experiment types (global sensitivity analysis, time course analysis, and convergence testing). The proposed framework can be the starting point for further automation of simulation experiments and, therefore, can assist in conducting simulation studies in a more systematic and effective manner. For example, based on this MDE framework, approaches for automatically selecting and parametrizing experimentation methods, or for planning follow-up activities depending on the context of the simulation study, could be developed.

Smart environments demand novel paradigms offering easy configuration, programming and deployment of pervasive applications. To this purpose, different solutions have been proposed ranging from visual paradigms based on mashups to formal languages. However, most of the paradigms proposed in the literature require further external tools to turn application description code into an executable program before the deployment on target devices. Source code generation, runtime upgrades and recovery, and online debugging and inspection are often cumbersome in these programming environments. In this work we describe a methodology for real-time and on-line programming in smart environments that is compact and efficient enough to run on resource-constrained devices. The pillar of the proposed approach is real-time exchange of executable symbolic code in heterogeneous networks. The methodology is supported by an inference engine that is able to generate symbolic code starting from knowledge about hardware devices and their placement in the environment, and about the application domain. Interoperability with existing smart applications and Internet of Things (IoT) deployments is reached through a symbolic Transmission Control Protocol (TCP) client, and Message Queue Telemetry Transport (MQTT) client.

Multi-Agent Based Intelligent Tutoring System Source Code Generation Using MASITS ToolSeveral agent development tools have been proposed. At the same time, specific tools for agent based Intelligent Tutoring System (ITS) development do not exist. However, ITSs have some specific characteristics that must be taken into consideration during the development. General purpose Agent Oriented Software Engineering (AOSE) methodologies and therefore development tools do not sufficiently correspond to the characteristics of ITSs. Additionally, the general purpose AOSE methodologies and tools do not allow plugging in domain specific rules and diagrams. Thus, usage of knowledge gained in ITS research during the development process is limited. In the absence of general tools that allow plugging in knowledge from ITS research, a specific tool named MASITS has been developed. The tool supports a specific agent based ITS development methodology named MASITS which takes into consideration specific characteristics of ITSs and integrates knowledge from ITS research. The tool supports all phases of ITS development, starting from requirements analysis and ending with deployment. Requirements analysis and design phases are supported by appropriate diagram creation tools. Implementation is supported by source code generation from diagrams created during the design phase. JADE platform is used for agent implementation. Thus, Java classes for ontology, agents and behaviours are generated from the design diagrams. The paper includes a brief overview of diagrams used in the source code generation and detailed algorithms for source code generation from the diagrams.

Der Ausdruck Quality of Service (QoS) beschreibt die Güte eines erbrachten Dienstes. QoS beschreibt Eigenschaften wie Antwortzeit, Verfügbarkeit, den Grad der Nachrichten-Verschlüsselung oder den Durchsatz. QoS ist sowohl für Multi-Media Anwendungen (Audio- und Video-Übertragung) als auch für Geschäftsanwendungen wichtig. Die vorgelegte Arbeit konzentriert sich dabei auf das Feld der Geschäftsanwendungen. Solche Anwendungen arbeiten mit Transaktionen wie etwa dem Bestellen eines Produkts oder der Überweisung von Geld zwischen Konten. QoS Eigenschaften solcher Anwendungen sind beispielsweise die Anzahl an Transaktionen während eines Zeitintervalls, die maximale Anzahl gleichzeitig mit dem System arbeitender Nutzer, oder die zu erwartende Verfügbarkeit. Durch Middleware kann die Realisierung von Verteilung vor dem Programmierer verborgen werden. In einer idealen Welt würde Middleware dasselbe für QoS leisten. Das heißt, der Entwickler spezifiziert nur die gewünschte Dienstgüte und kümmert sich nicht darum, wie sie realisiert wird. Das ist so aber nicht möglich, denn die zu erbringende Dienstgüte hat massive Auswirkungen auf das Design einer Applikation. Daher muss QoS schon in der Design-Phase angegangen werden, was mit einer rein Middleware-gestützten Herangehensweise nicht möglich ist. Die vorgelegte Arbeit zeigt, wie dieses Problem durch einen modellgetriebenen Ansatz behoben werden kann. Die Entwicklung beginnt dann mit einem Plattform-unabhängigen Modell (PIM), welches das Verhalten und die QoS Eigenschaften der Applikation beschreibt. Dieses Modell wird automatisch durch eine Modell-Transformation in ein Plattform-spezifisches Modell (PSM) umgewandelt. Das PSM beschreibt das Design einer Implementierung für eine spezifische Plattform und berücksichtigt dabei die im PIM beschriebenen QoS-Eigenschaften. Um dieses Szenario in der Praxis anwenden zu können, müssen zwei Probleme gelöst werden: das Modellieren von QoS Eigenschaften und die Modell-Transformation. Gegenwärtig erfordert das Erstellen einer Modell-Transformation detailliertes Wissen über die Modellierungssprache und ihre Interna. Um das zu vereinfachen, wurde im Rahmen dieser Arbeit die visuelle Regelbasierte Transformationssprache Kafka entwickelt. Kafka und die zugehörigen Werkzeuge bauen auf Graphtransformations-Theorie auf. Kafka vereinfacht das Erstellen von Transformationen weil es auf der Notation des PIM und PSM aufbaut. Daher muss der Entwickler nichts von den Interna (etwa dem Meta-Modell) verstehen. Um PIMs von QoS-fähigen Applikationen zu erstellen, wurde die Modellierungssprache PIQML entwickelt, welche auf UML 2.0 Komponenten, Hierarchischen Nachrichten Sequenz Diagrammen (HMSCs) und einer neuen Meta-Modell Erweiterung für QoS Verträge basiert. Die vorgelegte Arbeit zeigt, wie PIQML Modelle auf verschiedene Zielplattformen (Programmiersprachen und Middleware Produkte) abgebildet werden können. Basierend auf PIQML und Kafka wurde das Werkzeug Kase entwickelt, welches das Editieren von PIQML Modellen (PIMs), UML Modellen (PSMs) und Kafka Transformationen integriert. Das Ergebnis ist eine integrierte Werkzeug-Kette für das modellgetriebene Entwickeln QoS-fähiger verteilter Applikationen.

Many safety-critical real-time embedded systems need to meet stringent timing constraints such as preserving delay bounds between input and output events. In model-based development, a system is often implemented by using a code generator to automatically generate source code from system models, and integrating the generated source code with a platform. It is challenging to guarantee that the implemented systems preserve required timing constraints, because the timed behavior of the source code and the platform is closely intertwined. In this paper, we address this challenge by proposing a model transformation approach for the code generation. Our approach compensates the platform-processing delays by adjusting the timing parameters in system models, based on an Integer Linear Programming problem formulation. We demonstrate the usefulness of our approach via a case study of infusion pump systems. Experimental results show that the code generated using our approach can better preserve the timing constraints.

When the amount of available data is small with respect to the problem size, many Bayesian networks can account for the data in a similar way. In these cases model averaging offers a framework which allows us to make better predictions than model selection. Selective model averaging directly uses a subset of these networks with high probability mass to reason over the probability of the structural features (arcs) which can appear in the problem domain network model. In this paper, instead of using this subset of networks to reason about the domain network structure, we propose to use the probability distribution over the structural features induced by these networks, in order to learn a new Bayesian network whose variables are the structural features which can appear in the problem domain network. This network can be considered as a higher level model or meta model, because it can be seen as an approximation of the whole space of Bayesian networks defined over the problem domain variables. This meta-model (Bayesian network) can be used to reason about the probability of structural features, as selective model averaging, but also as a decision support tool to be used by an expert in the problem domain.

Early phases of the Software Development Life Cycle (SDLC) like requirements elicitation and model design are often critical for the project success. These phases are also linked to several project problems and failure causes, delaying the project finalization and increasing its total cost. Several strategies to mitigate the effects of errors in these early stages have been proposed. Some of these include: GUI based fast prototyping; agile software development methodologies; and, as in this work, automatic model (or source code) generation from a natural language specification. Although these approaches can reduce production time and costs, they can also be slow and imprecise leading to development difficulties. This work proposes an approach to obtain a functional prototype of a web-based process-oriented information system, using only a restricted natural language specification as an input. This approach allows the processing of the input to be faster and more precise than the approaches proposed previously. Two case studies are presented in order to validate the proposal and demonstrate its applicability.

Critical systems are present in our daily life and affect many aspects providing essential support to several human activities; they are employed in several application domains, providing support to economic activities, transportation, communication, health-care. Such systems must meet strict non-functional requirements, including dependability requirements, and should be able to cope with competitive market needs. Their criticality implies the necessity to meet several requirements, often dictated by international standards, whose fulfillment must be demonstrated in order to achieve necessary certifications. Quantitative evaluations are hence needed to assess and demonstrate compliance with target requirements, since design phases of the lifecycle. For this purpose modeling approaches have been investigated during the years; their aim is to have a of the overall system which allows to assess and demonstrate these properties. It is commonly known that the adoption of formal models in industry, although if strongly recommended when not mandatory, is slowed down by difficulties dictated both by the complexity of the models (which reflects the complexity of the systems) and by the need to have skilled staff in the usage of formal languages. For this reason, also if the academic research trends have focused on complex modeling approaches and techniques, formal models are not so used in industries: in particular only combinatorial models are widely adopted, thanks to their intuitive representation. The great simplifications introduced by combinatorial models lead to approximated results, hence system designers do not trust in them. In the last years the need of a model engineering is noticed: there is the necessity to define appropriate methodologies and processes to support development activities of complex models, aiming at improving the quality/cost ratio. In this way three main research trends have been introduced: formal models generation, multiformalism, and compositional approaches. This thesis aims at defining a methodology for quantitative analysis of critical system that can integrate Model-Based evaluations, conducted by using formal models, with Model-Driven Engineering (MDE) paradigms, taking advantage of the actual research trends. More in detail, according to such approach, critical systems properties can be assessed starting from high level models expressed in proper languages (usually called Domain Specific Modeling Languages - DSMLs), and defining automatic transformation chains, able to generate formal models. The methodology is implementable into cost-effective processes in order to reduce time-to-market specifically during verification stages of critical system development lifecycles. Such objective will be achieved by both improving usability and re-usability of typical Model-Driven artifacts. The adoption of this methodology for railway system dependability analysis may lead to an estimated costs reduction of approximately 30%. The usage of a high-level central language significantly decreases also the training time of new analysts, as they only need to learn the DSML usage (properly developed for the application domain). This thesis defines also two high-level modeling languages: the first, CIP_VAM, has been defined to vulnerability aspects of physical infrastructures, while the second, DAM-Rail, allows the dependability modeling in railway domain. Another important contribution of this thesis is given in the definition of new methods and formal operators: in detail a reference architecture for performability and Quality of Service evaluation is defined, as well as the formal concept of Model Template is introduced (to enable reuse). At last two techniques which deals with scalability are addressed: stub and reduced models. Even if the focus is on quantitative evaluation, the proposed methodology is useful also for the complete design (based on centralized informations), hence it is possible to extend it for automatic generation of documents and, more generally, of all those artifacts which support system development. The proposed approach has been applied with different goals to case studies coming from three different domains: railway systems, conferencing systems, and sensor network. These systems have different and complementary properties in terms of number of involved components, scalability, etc. Produced models are described, and obtained results are shown and commented.