No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Executable UML: A Foundation for Model-Driven Architectures
Abstract
From the Book:At one time, the title for this book was Executable UML For Model-Driven Architectures (MDA) Using Aspect-Oriented (AO) Techniques with Extreme Programming (XP), Agile Modeling (AM), and Other Agile Alliance (AA) Processes as an Instance of the Rational Unified Process (RUP). Eventually, we settled instead on Executable UML: A Foundation for Model-Driven Architecture. This title is snappier, but it's not fully buzzword-compliant, nor is it as descriptive as the original.So what is this Executable UML? It is a profile of UML that allows you, the developer, to define the behavior of a single subject matter in sufficient detail that it can be executed. In this sense, the model is like code, but there's no point in writing "code" in UML just to rewrite it in Java or C++, so it's rather more revealing to examine what executable UML doesn't say that code might.An executable UML model doesn't make coding decisions. It makes no statement about tasking structures; it makes no statement about distribution; it makes no statement about classes or encapsulation. An executable UML model describes only the data and behavior, organized into classes to be sure, about the subject matter at hand. In other words an executable UML developer describes subject matters at a higher level of abstraction than she would in a programming language.To build a system, we build an executable UML of each subject matter. Typically, the system includes subject matters such as the application, a user interface and some general services. The executable UML models for each of these subject matters are then woven together by an executable UML modelcompiler.The model compiler targets a specific implementation embodying decisions about "coding:" tasking structures, distribution, data structures (which may be quite different from that suggested by the class structure), as well as the language. Model compilers can be extremely sophisticated, taking care of cross-cutting concerns such as transaction safety and rollback, or they can be sophisticated in a different way, targeting small footprint embedded systems with no tasking or other system support.In general, a model compiler compiles several executable UML models, each of which captures a single cross-cutting concern to yield the running system. In this sense, executable UML makes use of the concepts in aspect-oriented programming.Executable UML models support a new Object Management Group initiative, Model-Driven Architecture (MDA). This initiative is in its early stages, but its goal is to allow developers to compose complete systems out of models and other components. This goal requires at least an interface as contract and, behind the interface, the ability to express a solution without making coding decisions. That would be executable UML, or some variation.This book does not describe model-driven architecture or its implications. Rather, this book focuses on one aspect of MDA that we believe to be critical: the ability to model whole subject matters completely and turn these models into systems. This ability, we believe, relies on being able to execute models. Hence executable UML.Because the developer builds models as executable as a program for each subject matter, all the principles of extreme programming and agile processes can be applied. Indeed, many of the principles of these processes having nothing to do with coding per se.You can use Executable UML in a deliberate process or, because the models are executable, an agile one. Our preference is agile and incremental because it keeps the focus on delivering working software.And what about RUP? As one of our reviewers, Martin Fowler, so memorably said: "My biggest concern with RUP is that it's so loose that any process seems to qualify as an instance of RUP. As a result, saying you're using RUP is a semantics-free statement." So, we can reasonably assert that the process described by this book is an instance of RUP, and if you want, we do.Frequently Asked QuestionsIs this the only possible Executable UML?No. This rendition views each object as potentially having a state machine that can execute asynchronously and concurrently. We view this approach as necessary for today's distributed computing environments. However, one could define an executable UML that relies on synchronous method calls between objects to produce a completely synchronous model of the subject matter. Similarly, our particular use of the statechart is not the only possible one.Is Executable UML a Standard?Yes and No. The notational elements you'll see in this book conform to UML, and so qualify as a profile of that standard. In addition, the execution semantics defined here conform to UML, though we do both subset UML and impose certain rules to link the elements together. What is not yet a standard is the exact content of what can and should be interchanged so that we can guarantee that any and all model compilers can compile any arbitrary executable UML model.Throughout this book, we use standards as much as they are established. In some areas, the book is intended to provide a basis for discussion of what should ultimately become a standard.Will there be a standard one day, and how might it differ?Yes, we hope so. Work has begun informally to define a standard and we will encourage and support it. We expect the standard to define the underlying semantics quite closely to what is outlined here, and to layer increasingly rich syntax on top.Does that mean I should wait?Not at all. This technology is taking off, and the basic elements are already established. Get ahead of the learning curve.I know nothing about UML. Is this book too advanced for me?We assume you have an intuitive understanding of the goals behind UML, but nothing more. We will show you all the elements you need to build an executable UML model.I'm a long-time UML user. Do I need this book?If you want to garner the benefits of executable UML, then you'll have to learn the elements that make it up. Focus on the definitions we use and the chapters that show how to build and execute models. Skip the notational stuff. Be prepared to unlearn some UML (and some habits of mind induced by UML) that is required to model software structure, but not required to specify an executable model.What happened to model adornments such as aggregation or composition?We don't need them for Executable UML. UML enables you to model software structure but that's not our purpose here so those adornments, and many others, are not in our profile.Some of this seems familiar. Is this just Shlaer-Mellor in UML clothing?Executable UML and Shlaer-Mellor share common roots. Both focus on execution and specification of an abstract solution, not on specifying software structure. Executable UML uses UML notation, which makes execution concepts accessible to a broader community.I've used Shlaer-Mellor before. Is this any different?A lot can happen in this industry in ten weeks, let alone the ten years since the publication of Object Lifecycles. First of all, of course, we all now use UML notation and vocabulary. (Resistance was futile.) Executable UML takes a more object-oriented perspective, no longer requiring identifiers or referential attributes, or other traces of Shlaer-Mellor's relational roots.The addition of an action language that conforms to the UML is a major step forward. We hope the action language, and the very concept of an executable and translatable UML may one day be seen as a significant contribution of the Shlaer-Mellor community.And finally, progress in tools makes certain conventions, such as event numbering, less critical to model understanding, though they are still helpful in keeping our minds clear.A complete list of correspondences and differences appears in Appendix E.How can I get an Executable UML tool?All of the examples in this book were developed using Project Technology's tool, BridgePoint. A copy of BridgePoint can be downloaded from our book's website, http://www.projtech.com/.How is this differnt from the old "draw the pictures, get some code" CASE tools?There are two main differences. First, compiling models produces the whole system, not just interfaces or frameworks. Secondly, there are many different model compilers available to buy, and even more that can be built, to meet exacting software architecture needs.Where has Executable UML been used?Executable UML has been used to generate systems as large as four million lines of C++, and as small as hand-held drug delivery devices. Executable UML has also been used in lease-origination, web-enabled executive reporting, and intermodal transportation logistics systems.Why did you write this book?Because we had nothing better to do? No: There are lots of books out there that tell you about UML notation, but few of them focus attention on the subset you need for executability. Many books use UML to describe software structure. We explicitly spurn this usage.Why should I buy this book?Because it describes completely everything you need to know about executable UML: it's the Executable UML handbook.
... Be tradicinėmis tapusių UML kalbos priemonių, vykdomojoje UML įvesta klasių veiksmų (angl. Class Actions) semantika (Mellor, Balcer, 2002). Klasių (šiuo atveju -esybių) veiksmai aprašomi specialia klasių veiksmų kalba (KVK) (OMG, 2002). ...
... Klasių veiksmų naudojimas padeda aprašyti dalykinės srities logiką, o vėliau -vykdymo logiką, abstrahuojantis nuo konkrečių platformų ir kitų detalių. Pažymėtina, kad kaip veiksmų aprašymo kalbą galima naudoti ne tik KVK, bet ir kitas veiksmų aprašymo kalbas, pavyzdžiui, Schlaer-Mellor (Mellor, Balcer, 2002) kalbą. Ribojimus, kuriuos privalo tenkinti dalykinės srities komponentai, tikslinga aprašyti OCL kalba. ...
... Konkretusis modelis, aprašytas vykdomąja UML kalba, suvokiamas kaip modelio kompiliavimo proceso parametras (Mellor, Balcer, 2002). Šiame modelyje jau atsispindi komponento modelio, karkaso ir kt. ...
Modelinė architektūra gana paplitusi, tačiau jos taikymai komponentinei paradigmai yra tik daliniai – neatsižvelgiama į reikalavimą atskirti komponentų ir komponentinių sistemų kūrimo procesus. Šio straipsnio tikslas – aprašyti modelinės architektūros naudojimo automatizuotai kuriant komponentines programų sistemas iš binarinių komponentų metodą, atsižvelgiant į Išrink–Pritaikyk–Testuok gyvavimo ciklo reikalavimus. Straipsnyje atskleista komponentinių programų abstrakčiųjų ir konkrečiųjų
modelių specifi ka, aprašytos jų transformacijos. Nustatyta, kad modelinė architektūra su pakeitimais gali būti naudojama ir komponentinių programų sistemų kūrimo iš binarinių komponentų procesui automatizuoti, pateiktos jos tobulinimo gairės.
The Application of MDA for Component-based Software Development
Vaidas Giedrimas
Summary
The Model-Driven Architecture is relatively widely used but the conjunctions of MDA and Component-Oriented Paradigm are still partial only. According Component-Oriented Paradigm there is clear division of component-based software engineering to the component development and componentbased development, but unfortunately in existing approaches this principle is avoided. The aim of this article is to describe the method of MDA in automated component-based software synthesis from binary components process, having in mind the singularities of Select-Adapt-Test lifecycle. The key points of modifi ed component-based MDA are covered including platform-independent models, platform-specifi c models and transformations.
... Extreme Programming (XP) could be considered to be a primary methodology that made ASD got attention; it was a dominant methodology in the late 90s to 00s before Scrum has begun the dominant Agile methodology 6 . It had been developing by Kent Beck during his consulting to Smalltalk projects in the late 80s and early 90s [12,96]. It was created to answer the long development cycles of the waterfall model. ...
... The characteristics of XP are short development cycles, incremental planning, continuous feedback, reliance on communication, and evolutionary design [12]. It promises to reduce project risk, improve responsiveness to business changes, improve productivity throughout the life of the system, and add fun to building software in teams-all at the same time [96]. ...
... UML [58] "An activity is a computation that executes for the duration of state." UML [96] "A use case specifies an interaction between the sys- tem and one or more actors together with the activi- ties performed by the system.. ...
... A combined agile and MBD approach could help to address the problems with the individual agile and MBD approaches, as shown in Table 1. The idea of combining MBD and agile approaches into an 'agile MBD' approach has been explored by several researchers, and a small number of agile MBD approaches have been formulated and applied: Executable UML (xUML) [12]; Sage [13]; MDD System Level Agile Process (MDD-SLAP) [14], and Hybrid MDD [15]. Hybrid MDD introduced the concept of a tooling (MDD) team working together with agile development and business analysis teams, whilst MDD-SLAP maps MDD process activities (requirements analysis and high-level design; detailed design and code generation; integration and testing) into three successive sprints used to produce a new model-based increment of a system. ...
... In contrast to other MBD tools, UML-RSDS emphasises simplicity: it uses a single UML model (class diagrams with use cases) instead of multiple models, thus removing the overhead of maintaining model consistency. It uses a simplified UML and OCL notation, and a higher level of abstraction compared to approaches such as xUML [12] or FUML [24] -constraints, instead of detailed action language code -thus providing a more concise and clearer specification, closer to the informal business rules and the requirements of the system. The UML-RSDS tools provide support for extensions to define new code generators, and also provide facilities for interoperation with Eclipse. ...
Model-based development (MBD) is the development of software systems using graphical and textual models such as UML class diagrams. MBD and related approaches such as Model-driven development (MDD) have had some success within specific application domains, such as the automotive industry. Agile software development approaches such as Scrum and eXtreme Programming (XP) have been widely adopted in many different industry sectors. These approaches emphasise iterative development and close customer collaboration. eXtreme Modeling (XM) is a model-based development analogue of eXtreme Programming: it is an agile development approach based on the use of software models to specify and synthesise software systems. In this paper we look at the track record of agile and model-based development, and we consider the case for combining these approaches into XM to obtain benefits from both approaches: rapid automated software generation, lightweight development processes, and direct customer involvement. An example application of XM in the financial services domain is described.
... There are many reasons to require the executability of abstract programs. A pragmatic one is that a program that runs fits the computational mind of the engineers; not surprisingly, today a large community of practitioners use executable UML [46] for software specifications. 13 We mention here only three more reasons that are related to the documentation issue. ...
We present Executable Abstract Programs and analyse their role for software development and documentation. The intuitive understanding of these programs fits the computational mindset of software system engineers and is supported by a simple but precise behavioural definition. Therefore, they can be smoothly integrated in the practitioner's daily work to rigorously formulate every design and implementation decision taken on the path from the Executable Abstract Program for the requirements to the targeted and efficiently runnable code. The Executable Abstract Programs of the resulting system documentation represent definitions of implementation steps one can check and justify by testing (due to their executable character) or by reasoning (due to the mathematical definition of their behaviour). For complex systems the implementation involves multiple (orthogonal or successive) implementation steps which represent instances of a practical computational refinement concept. Such a system development process is driven by computational refinements and is strictly limited to explicitly formulate and justify -- besides the requirements -- only the necessary implementation steps. As a consequence, it produces as side-effect a corpus of documentation that facilitates the understandability of the final code and improves its reliability and resilience; it also enhances the maintenance process (including reuse and change of abstract programs and code) and reduces maintenance cost.
... The software product was developed in C ++ using an object-oriented approach, which made it possible to make a modern scalable application [8][9][10]. Working with COM ports is implemented using WinApi [11,12], working with the PCI-1710 board-using a third-party library bdaqctrl.h, distributed free of charge [13]. ...
This work is devoted to the issue of beam output optimization during electron beam welding of thin-walled structures. Authors develop a model for optimizing the electron beam output mode, which considers the dynamics of the thermal process in the welded joint zone and depends on the electron beam input mode, the geometric dimensions of the product, and the technological parameters used in the welding process. Based on the proposed approach, a prototype of a software control system for electron beam welding with optimization of the electron beam output was implemented, which allows control at all stages of the technological process.
... Certainly, UML models can be executable, too (cf. [33]). In the table, we refer to UML as visualization of source code. ...
Context: The importance of software maintainability is well understood and researched in software engineering, in general. Various metrics exist to evaluate this software quality attribute, predominantly for object-oriented and open-source software. At the same time, there is a lack of a similar understanding and concrete metrics for software maintainability of executable models, which are widely adopted in the industry, pre-dominantly, using Simulink. Objective: We address this shortage by investigating how maintainability is understood and measured for Simulink models. Method: We combine a comprehensive literature study with an extensive industry survey. In the literature re-view, we elicit present metrics and their goals. In a subsequent survey, we investigate how practitioners perceive maintainability when using Simulink models, which aspects they associate it with, and to what extent they agree with the previously elicited metrics. Results: The literature review resulted in a collection of16 metrics currently used in research to assess maintain-ability of executable models. We categorized them and extracted 23 re-occurring base measures to outline the current state-of-the-art of maintainability measurement in the field. In the consecutive survey, we collected 256maintainability aspects, grouped into eleven categories and 77 sub-categories. Lastly, we provide rankings for aspects and measures.
... While implementing the PET model in a lower-level language, such as C++ or Fortran, is likely to be more efficient than in a more user-friendly language, such as Julia, MATLAB, or Python among others, the learning curve for beginners can be steeper [22]. High performance models written in MATLAB and Python often necessitate the functions to be converted to a faster, low-level language (also known as the "two-language" problem [23,24]) which can hinder code modification and debugging -Julia avoids this issue since its compiled code speed is comparable to C++. Julia was ultimately chosen for its open-source license, its relative ease of use, fast speed after compilation, and the growing ecosystem for tools like neural ODEs and physics-informed neural networks. ...
This article presents PETLION, which is an open-source, high-performance computing implementation of the porous electrode theory (PET) model in Julia. A typical runtime for a dynamic simulation of full charge or discharge is 3 ms on a laptop while allocating about 1 MB of total memory, and the software is seen to be two orders of magnitude faster than comparable software for some applications. At moderate spatial resolutions, the computation times are similar to those of reduced-order and reformulated models in the literature. Multiple numerical solvers and methods for their initialization are compared in terms of numerical convergence and computational times, for a wide variety of operating conditions. PETLION is shown to quickly and robustly simulate complex battery protocols such as the Galvanostatic Intermittent Titration Technique (GITT), and to achieve high performance when incorporated into real-time PET-based nonlinear model predictive control.
... Tools developed for these methods enable code generation for producing code snippets and programs in target programming languages. An earlier work is executable UML [21]. More recently, the foundational subset of UML (fUML) [22] formalizes a subset of the UML using a set of actions with more elaborate semantic definitions and an execution model. ...
This paper presents our findings for using activity modeling for simulation (validation), model checking (verification), and execution purposes. Each is needed to tackle system complexity and further research into behavioral modeling. We argue different models implicate different understandings and expectations. We emphasize some distinctions with demonstrations using the Discrete Event System Specification with an exemplary model. In particular, the continuous-time base in models helps observe some inherent limitations and strengths in acquiring each capability. The temporal characterization of input, output, and state, or the lack thereof, is at the core of developing behavioral specifications. We use DEVS to arrive at the capability of validating simulations for activity models. We use Constrained-DEVS for the verification of activity models. We show how some executions can be derived, whether from the specification itself or with considerations for simulation and model checking.
... Substantial resources for training in both the language and the associated method are available, including webinars and custom courses (see https://xtuml.org/learn/ ). An excellent starting point for learning about the language and its design philosophy can be found in the book by Balcer and Mellor [2]. ...
... In the MDE community, common interest in MDE and AI is also quite recent, a first workshop on AI and MDE was held in 2019 (Burgueño et al., 2019). Regarding model execution, a large number of related works are available, published in the last two decades in the literature, around the formalisation and execution of UML models (Object Management Group, 2018;Shah et al., 2009;Mellor et al., 2002), but none of these approaches tackle specifically the modeling of datasets requirements for DL-based systems. ...
... Resolution Executable UML [MB02] provided a plausible mechanism to model precision, but it was not adopted by UML 2. It did however influence the OCLforUML profile [Wil15b] that users apply to their UML models. ...
... When the required models are available for the analysis phase, the Evaluation Engine (4.a) implemented with a Java model parser can be invoked. Through model interpretation also called compilation, the input models are directly used to run the system [24] or to invoke other actions during the interpretation at runtime. As before, the analysis phase will generate the evaluated KPIs model, however the console output in the hybrid specification is only used for testing purpose, being accessible only from the server-side. ...
The concept of smart and sustainable city has been on the agenda for the last decade. Smart governance is about the use of innovation for supporting enhanced decision making and planning to make a city smart, by leveraging on Key Performance Indicators (KPIs) as procedural tools. However, developing processes and instruments able to evaluate smart cities is still a challenging task, due to the rigidity showed by the existing frameworks in the definition of KPIs and modeling of the subjects to be evaluated. Web-based platforms, spreadsheets or even Cloud-based applications offer limited flexibility, if the stakeholder is interested not only in using but also in defining the pieces of the puzzle to be composed. In this paper we present a flexible architecture supporting a model-driven approach for the KPIs assessment in smart cities. It identifies both required and optional components and functionalities needed for realizing the automatic KPIs assessment, while showing flexibility points allowing for different specification of the architecture, thus of the overall methodology.
... The presentation will cover strategies for decoupling business knowledge from technology that are incremental improvements over the status quo. And it will conclude by positing that the approach of modeldriven development with executable models [Mellor, 2002], while requiring a significant change on the way software is built, is very effective at fully breaking the dangerous businesstechnology tangle apart, leading to applications that are much easier to build and adapt to changes in both business and technology fronts. The presentation will include a demonstration of a tool that follows the approach. ...
Tem como objetivo apresentar uma ferramenta de gerência de projetos chamada Gestão Integrada, desenvolvida pelo Núcleo de Engenharia de Software do Instituto Federal de Educação, Ciência e Tecnologia Fluminense. A ferramenta baseia-se em um framework eletrônico capaz de agregar em único local todas as informações dos projetos de uma organização, favorecendo os projetos desenvolvidos de forma colaborativa, ajudando a eliminar a redundância de documentos e ferramentas diversas, reduzindo o desperdício causado pela alocação ineficiente de recursos e a duplicação de esforços em projetos.
... Un modelo ejecutable es una abstracción que permite describir y definir la conceptualización y comportamiento de un dominio real o hipotético de estudio. Además, cuentan con semánticas que permiten definir acciones (Stephen J. Mellor, 2002). El EP se enmarca dentro de esta definición, puesto que los EP ejecutables tienen elementos que permiten representar acciones que se procesan internamente en el modelo (Chaverra, 2011). ...
Enhanced oil recovery (EOR) processes simulation is governed by mass conservation laws. In such laws, flow, accumulation, sources and sinks phenomena in porous media are described. Multiple proposals for framework and simulation elaboration have been defined. However, they lack concepts and processes tracing and event representation for physical phenomena. Preconceptual Schemas (PS) are used for including the complete structure of an application domain and representing processes emerging in such a domain. Cohesion, consistency, and tracing between concepts and processes is obtained by using PS. In this MSc. Thesis an executable model for enhanced oil recovery processes simulation based on preconceptual schemas is proposed. The executable model is validated by running a study case. The results are in accordance with data reported in the literature. The proposed executable model allows for tracing consistently the concepts, processes, and events, which are present in EOR processes simulation.
Access Link:
https://repositorio.unal.edu.co/handle/unal/75603
... UML is used to determine, visualize, build, and document in establishing a system with a specific programming language code. UML diagrams in this study are described in the form of Use Case Diagrams that are the provided functions of the system as units to exchange messages between units or actors [29] and Class Diagram is a type of static structure diagram that describes the structure of a system by showing system classes, its attributes, operations (methods), and relationships between objects [30]. There are two User Interfaces produced in this study, they are front end (for users) and back end (for administrators). ...
Funds can be used for any purpose, both for physical and non-physical purposes, for example: infrastructure, scholarships, social activities, and etc. The limited budget and the large number of needs make fundraising occasionally necessary. Fundraising is usually held by non-profit organizations. In fact, fundraising usually meets with several obstacles, such as: the amount of time and resources to deliver information, low accuracy in disseminating information, less choices methods of funding, low level of public trust, and less optimal of fundraising calculation. According to the obstacles above, one of the solutions is to produce a mobile-based software application to raise fund. The application is developed with the Scrum framework to make it faster to be resolved, by using the scrum framework, completing a mobile application for fundraising only takes 35 days. The application makes disseminating information, notification system, and the community easily to access and provide fund in real time. It is also help the process of collection and calculation discovered in real time. SUS examined the usability of this mobile application and the result is 82.1%.
... The conception of the MDA supports abstraction and refinement in models [3,4]. Models can be described in any modeling language defined in accordance with the MDA Foundation Model [5]. ...
Transformation from model to model takes significant place in Model Driven Architecture (MDA). Model Driven Architecture considers system from three viewpoints: computation independent, platform independent, and platform specific. Despite the fact that each viewpoint has its own representing model, the transformation between computation independent model (CIM) and platform independent model (PIM) is fuzzy. In this paper is proposed topology oriented approach for CIM to PIM transformation and PIM representation. To-pology used within this approach is borrowed from Topological Functioning Model (TFM). TFM uses mathematical foundations that holistically represent complete functionality of the problem and application domains and therefore can be used as CIM and as a source for transforming CIM to PIM. Application of TFM within software development process enables formal analysis of business system and formal designing of system structure. Software development begins with TFM creation. After construction of business system's TFM by applying transformation on TFM a system structure representing PIM is defined. As a basis for system structure definition is used topological class diagram. Topological class diagram is combination of Unified Modeling Language (UML) class diagram and topology borrowed from TFM.
... Another approach is the executable Unified Modeling Language with its standard Foundational Unified Modeling Language (fUML). The fUML is a subset of the graphical notation of the UML with executable semantics in order to generate platform dependent software [4]. Based on the UML the executable Systems Modeling Language (SysML) was developed in the field of systems engineering. ...
This paper proposes a Python-based infrastructure for studying the characteristics and behavior of families of systems. The infrastructure allows automatic execution of simulation experiments with varying system structures as well as with varying parameter sets in different simulators. Possible system structures and pa-rameterizations are defined using a System Entity Structure (SES). The SES is a high level approach for variability modeling, particularly in simulation engineering. An SES describes a set of system configurations, i.e. different system structures and parameter settings of system components. In combination with a Model Base (MB), ex-ecutable models can be generated from an SES. Based on an extended SES/MB approach, an enhanced software framework is introduced that supports variability modeling and automatic model generation for different simulation environments. By means of an engineering application it is shown, how a set of Python-based open source software tools can be used to model an SES and to automatically generate and execute signal-flow oriented models.
... Unfortunately, the execution semantics for UML and SysML are not sufficiently precise to be unambiguous. This is broadly acknowledged, 10 and is the reason for industry initiatives such as State Chart XML 11 and Object Management Group (OMG) standards such as Foundational UML (fUML). 12 These standards provide a precise semantics to be used for the verification of SysML activity diagrams. ...
The development of contemporary systems is an extremely complex process. One approach to modeling system behavior uses activity diagrams from Unified Modeling Language (UML)/System Modeling Language (SysML), providing a standard object‐oriented graphical notation and enhancing reusability. However, UML/SysML activity diagrams do not directly support the kind of analysis needed to verify the system behavior, such as might be available with a Petri net (PN) model. We show that a behavior model represented by a set of fUML‐compliant modeling elements in UML/SysML activity diagrams can be transformed into an equivalent PN, so that the analysis capability of PN can be applied. We define a formal mathematical notation for a set of modeling elements in activity diagrams, show the mapping rules between PN and activity diagrams, and propose a formal transformation algorithm. Two example system behavior models represented by UML/SysML activity diagrams are used for illustration.
... 用户在传统软件开发过程中可以使用统一建模语言 UML 比较好地刻画一个大型 (面向对象) 软 件的组织结构和逻辑模型 [74] , 结合这一需要, 文献 [75,76] [83] 和 VirtualBox [84] ), 借助 Intel/AMD 提供的硬件虚 拟化技术 (VT [85] ), 在保证安全性的同时能够极大提升虚拟化性能. Linux 以共享内核的方式达到高 效虚拟化的目的 (如 Xen [86] ), 虚拟化开销比传统虚拟机低很多, 但有 Linux 内核版本的限制. 而通过 Linux 内核提供的 Namespace, CGroups [87] 等进程组技术, 在 Docker 和 Rocket 等容器管理程序的帮助 下 [55] , 可以在隔离 Linux 进程组的同时, 让 Linux 进程以接近原生的性能运行, 当然不可避免的是安 全性较差. ...
... Papyrus [1] is a Unified Modeling Language (UML) [2] modeling tool for the Eclipse Modeling Framework [3] and provides tool support for executable UML modeling [4]. It includes technologies for the simulation and debugging of models, as well as editing facilities to produce executable models more efficiently. ...
The Foundational Subset for Executable UML Models (fUML) and the Action language for fUML (Alf) can be used for creating executable models in the Eclipse-based UML editing tool called Papyrus. An fUML execution engine in Papyrus, such as Moka, allows to simulate or execute fUML models along with their associated Alf code. However, for exhaustive simulation of such models, one must provide input data required to reach and cover all important elements not only in the graphical fUML models, but also in the textual Alf code. In this paper, we present MATERA2-AlfTester, an Eclipse-plugin for exhaustive simulation and test generation for fUML models. MATERA2-AlfTester integrates with Papyrus and Moka tools and extends their functionally by allowing one to automatically generate test data, test suite with test oracle, and partial Java code at design time. We also present the simulation and testing process of MATERA2-AlfTester with the help of an example and demonstrate how exhaustive simulation and test generation with MATERA2-AlfTester can help designers in assessing and improving the quality of fUML models.
... UML is a language used to define, visualize, build, and document when building systems with specific programming language codes. [15]. ...
_______________________________________________________________________________________ Abstract The government of Tegal city doesn't currently have the media used to publicize land use, the socialization of land use is rarely done, so that this may cause some problems, such as: there is land used for facilities that are not, the efficiency of land use is not maximal, the existing public services in the city of Tegal become obstructed and inhibit the productivity of existing resources in the city of Tegal. Land Use Mapping System in Tegal City Area becomes a solution to the problems. The system is made based on the website that can be used as a media mapping of land use area contained in the city of Tegal. The system can also present comparisons of land use in the Tegal area of the city each year differently, in addition the system can also be updated easily.
... Event-driven approaches in which the transitions are labelled by events are more popular for modelling the actions of an FSM. Over the years, many frameworks [27][28][29] have been developed for the implementation of such models. However, the event-driven-based models require implementation as a set of concurrent threads which communicate with each other. ...
Walking machines have proved to be an important invention as they do not require any prepared surface, making them ideal for applications involving unexplored environments. They are equipped with a large number of actuators and sensors to achieve a robust locomotion; thus, a systematic approach to designing their control system is required. This article presents a functional control structure based on the logic-labelled finite state automaton approach developed for walking machines. A general control structure is presented and a hexapod robot is used to verify the practicability of the design.
... The class diagram outlines conceptual entities in the domain while the state chart for each class models the object life cycle. The AD is used to model the behavior of a state in the state chart by exhibiting the sequence of actions to be performed in a particular state [13]. An executable model executes dynamic actions such as creating class instances, establishing associations, and performing operations on attributes and call state events. ...
The quality of the specifications used for test generation plays an important role in the quality of the generated tests. One approach to improve the quality of the UML specification is the use of executable models specified using the Foundational Subset for Executable UML Models (fUML) and the Action language for fUML (Alf). Due to their precise semantics, fUML and Alf models can be simulated or executed using an fUML execution engine. However, in order to execute the models exhaustively, one must provide input data required to reach and cover all essential elements not only in the graphical fUML models, but also in the textual Alf code associated with the graphical models. In this paper, we present an approach for exhaustive simulation and test generation from fUML activity diagrams containing Alf code. The proposed approach translates fUML activity diagrams and associated Alf code into equivalent Java code and then automatically generates: (1) input data needed to cover or execute all paths in the executable fUML and Alf models and (2) test cases and test oracle (expected output) for testing the actual implementation of the system under development. We also present a tool chain and demonstrate our proposed approach with the help of an example.
... A unified modelling language(UML) provides the developers of accessing varieties of options of conveying information of the development of the application in a visual form. According to Stephen J. Mellor [9], he believes that UML diagrams are a subject that "matters at a higher level of abstraction" rather than executing it in development. It is a very powerful statement regarding on the priority in process of developing an application. ...
Cognitive Behaviour Therapy is a very effective exercise course that has been
used around the world.The obsession on the exposure of a human's mindset defines
the obscurity of fear and patience. Providing the right resources for the right
individuals will compromise the patience of ones self as the frustrations decline.
As a minority value of individuals that are being able to afford the luxury of
hiring a therapy session with trained professionals, there are the major population
of individuals who suffer from general anxiety and same condition with the minority
that struggle due to the lack of financial stability. Also, as there are free services
that conclude and resolve the majority of individuals who cannot afford the
sessions. This will create an overpopulation of individuals that want to receive
treatment as there are no fees. Thus, including a limitation for the availability
for the treatment as well as the efficiency that the treatment is on ongoing. The
probability of availability for trained specialists become slimmer as more
as the value of individuals gradually increase. My application allows the users to
be exposed and taught in cognitive behaviour therapy environment as there will
be exercises that will take between the user and the application. In combination
with Augmented Reality, the succession of the user attention will be greater as
whereas the application where it only includes only contents, which might allow
the user to lose the immersion and the lack of attention to detail.
... Engineers from every domain have their preferred design tools to work with. For example, control engineering is done using LabView [25], LMS [28], Modelica [31], and Matlab/Simulink [39]; electrical engineers use Electronic Design Automation (EDA) design tools; mechanical engineering is supported by ComputerAided Design (CAD) and Engineering (CAE) tools; and software engineers use UML [30] and in-house software development environments [9]. However, the incompatibility between different domains has made it difficult to combine these tools to perform system-level analysis and simulations [17]. ...
Cyber physical systems (CPS) design has become more challenging due to the tight integration of the cyber and physical worlds and the use of cross-domain engineering practices. Moreover, competition in the market in terms of quality, innovation, cost, and time-to-market makes CPS design even harder for the engineers. These challenges advocate for the adoption of integrated engineering methods and tools by CPS design engineers. In addition, state-of-the-art engineering tools are very domain specific, making it difficult to integrate different tools for system-level analysis. This chapter discusses a novel multi-disciplinary systems engineering methodology and related design automation techniques for a complex CPS presented in Wan et al. (IEEE Syst J 11(4):2028–2039, 2017). Instead of domain-specific architecture/simulation models, this method directly targets the early design stage at the functional level. It enables the coupling of systems engineering principles with high-level synthesis techniques from the field of design automation. This blend results in a functional modeling synthesis tool capable of generating high-fidelity simulation models for the design space exploration and validation of multiple cyber-physical architectures. Using real-world automotive use-cases, it is demonstrated how functional models capturing integrated cyber-physical requirements are synthesized into high-fidelity multi-domain simulation models.
The Seventeenth International Conference on Software Engineering Advances (ICSEA 2022), held between October 16th and October 20th, 2022, continued a series of events covering a broad spectrum of software-related topics. The conference covered fundamentals on designing, implementing, testing, validating and maintaining various kinds of software. Several tracks were proposed to treat the topics from theory to practice, in terms of methodologies, design, implementation, testing, use cases, tools, and lessons learned. The conference topics covered classical and advanced methodologies, open source, agile software, as well as software deployment and software economics and education. Other advanced aspects are related to on-time practical aspects, such as run-time vulnerability checking, rejuvenation process, updates partial or temporary feature deprecation, software deployment and configuration, and on-line software updates. These aspects trigger implications related to patenting, licensing, engineering education, new ways for software adoption and improvement, and ultimately, to software knowledge management. There are many advanced applications requiring robust, safe, and secure software: disaster recovery applications, vehicular systems, biomedical-related software, biometrics related software, mission critical software, E-health related software, crisis-situation software. These applications require appropriate software engineering techniques, metrics and formalisms, such as, software reuse, appropriate software quality metrics, composition and integration, consistency checking, model checking, provers and reasoning. The nature of research in software varies slightly with the specific discipline researchers work in, yet there is much common ground and room for a sharing of best practice, frameworks, tools, languages and methodologies. Despite the number of experts we have available, little work is done at the meta level, that is examining how we go about our research, and how this process can be improved. There are questions related to the choice of programming language, IDEs and documentation styles and standard. Reuse can be of great benefit to research projects yet reuse of prior research projects introduces special problems that need to be mitigated. The research environment is a mix of creativity and systematic approach which leads to a creative tension that needs to be managed or at least monitored. Much of the coding in any university is undertaken by research students or young researchers. Issues of skills training, development and quality control can have significant effects on an entire department. In an industrial research setting, the environment is not quite that of industry as a whole, nor does it follow the pattern set by the university. The unique approaches and issues of industrial research may hold lessons for researchers in other domains. We take here the opportunity to warmly thank all the members of the ICSEA 2022 technical program committee, as well as all the reviewers. The creation of such a high-quality conference program would not have been possible without their involvement. We also kindly thank all the authors who dedicated much of their time and effort to contribute to ICSEA 2022. We truly believe that, thanks to all these efforts, the final conference program consisted of top-quality contributions. We also thank the members of the ICSEA 2022 organizing committee for their help in handling the logistics of this event. We hope that ICSEA 2022 was a successful international forum for the exchange of ideas and results between academia and industry and for the promotion of progress in software engineering advances.
We present executable documentation as a natural continuation of a long-term trend of documentation/code alignment that started with self-documenting code in the seventies (choice of meaningful naming), followed by literate programming (documentation embedded in code) and the dual where documentation embeds code as provided by Jupyter notebooks in the beginning of the new millennium. Executable documentation goes a step further by turning domain-specific notation and documentation languages typically used in the requirements and the design phase into fully-fledged modeling/programming languages. The resulting so-called Purpose-Specific Languages are meant to tighten the semantic gap, while directly covering the what, providing the how via automated transformation, and reduce the handwritten part to why the project is of importance. We will illustrate the impact of this approach in the DevOps scenario where we turn the graphical notation GitLab provides for documenting CI/CD workflows into an Integrated Modeling Environment called Rig. At a larger scale, Rig can be seen as part of our Language-Driven Engineering approach where it covers the aspect of CI/CD at the modeling level with a push-button link towards execution. This turns the corresponding running system into the ‘ultimate’ documentation where the understanding of all stakeholders should converge.
KeywordsAutomationDevOpsDocumentationCI/CDLanguage-Driven EngineeringPurpose-Specific Languages
Behavioural Modelling –
Foundations and Applications
BM-FA2011
http://www.ou.nl/bm-fa
In collaboration with the Seventh European
Conference on Modelling Foundations and
Applications ECMFA 2011
At universities, computer language handling is most often taught with a focus on compiler theory. However, in practical applications, domain-specific languages (DSLs) are much more important. DSLs implement model-driven technology in an understandable way, as models can be expressed easily using DSLs. One interesting domain for DSLs in this context is language handling itself, and many current tools for language handling are model-driven and based on meta-models. This chapter connects compiler theory and meta-modelling within a university course about language handling. The course features the relevant theory and uses MPS as a practical tool. We show how MPS is used in the course and discuss its suitability.
Die Entwicklung informationstechnischer Systeme ist grundsätzlich mit zwei großen Herausforderungen konfrontiert. Die erste: die Maschinen, die unsere Programme ausführen, kümmern sich nicht um Architektur und Stil, sind aber ausgesprochen pedantisch in Bezug auf Inhalte und ziemlich schlecht darin, Lücken zu füllen. Die zweite: Menschen sind keine perfekten Denker und sie neigen dazu, komplexe Probleme zu vereinfachen.
Enterprise information systems in agriculture and environment are becoming more complex and difficult to design and implement. This paper aims to show our vision on using model-based approaches to design complex and flexible agricultural and environmental information systems. At the center of this modeling approach is the Unified Modeling Language that facilitates expressing visually concepts of a problem domain and their relationships. UML has a core of notations that are generic and that can be used to model problems in any domain but can be extended to create profiles in order to take into consideration modeling concerns in a particular problem domain. UML profiles are created to use UML in designing spatial systems, ontologies, model driven architecture-based systems and Web-based systems and a recent profile makes it possible to use UML for business modeling purposes. UML is used to present design patterns; their use is crucial in designing complex and flexible information systems. Recently, UML is enriched with Object Constraint Language that is used to express constraints on modeling artifacts. The paper presents the state of the art in modeling agricultural and environmental systems and provides discussions for future directions.
Self-adaptation is a widely accepted approach to deal with uncertainties that are difficult to anticipate before deployment. We focus on architecture-based adaptation that relies on a feedback loop that reasons over architectural models of the system at runtime to make adaptation decisions. In particular, we study decentralized self-adaptive systems where self-adaptation is realized through multiple coordinating feedback loops. Such decentralization is crucial for systems where adaptation decisions cannot be made in a centralized way, such as in large scale Internet of Things (IoT). State of the art in this area is limited to either conceptual ideas or solutions dedicated to particular settings. This paper outlines a research project targeting the research question: “how to model and realize decentralized feedback loops that are capable to guarantee compliance of system goals in an efficient way despite uncertainties the system faces?” We plan to answer this question in two stage. First, we study commonalities and variability of decentralized self-adaptive systems leveraging on patterns and coordination mechanisms, and reify our insights in a framework. Second, we study language support for the design and implementation of decentralized self-adaptation, capitalizing on the outcome of the first stage. To ensure guarantees for the qualities we will found our work on formal techniques. To ensure efficiency, we will combine statistical techniques with machine learning. We plan to validate the research results in two domains: IoT and multi-cloud systems.
The Current Expected Credit Loss (CECL) revised accounting standard for credit loss provisioning is the most important change to United States (US) accounting standards in recent history. In this study, we survey and assess practices in the validation of models that support CECL, across dimensions of both model development and model implementation. On the development side, this entails the usual SR 11-7 aspects of model validation; however, highlighted in the CECL context is the impact of several key modeling assumptions upon loan loss provisions. We also consider the validation of CECL model implementation or execution elements, which assumes heightened focus in CECL given the financial reporting implications. As an example of CECL model development validation, we investigate a modeling framework that we believe to be very close to that being contemplated by institutions, which projects loan losses using time-series econometric models, for an aggregated “average” bank using Federal Deposit Insurance Corporation (FDIC) Call Report data. In this example, we assess the accuracy of 14 alternative CECL modeling approaches, and we further quantify the level of model risk using the principle of relative entropy. Apart from the illustration of several model validation issues and practices that are of particular relevance to CECL, the empirical analysis has some potentially profound policy and model risk management implications. Specifically, implementation of the CECL standard may lead to under-prediction of credit losses; furthermore, coupled with the assumption that we are at an end to the favorable phase of the credit cycle, this may be interpreted as evidence that the goal of mitigating the procyclicality in the provisioning process that motivated CECL may fail to materialize.
This chapter presents Methodical Approach to Executable Integrated Modeling (MAXIM) and its implementation environment, OPCloud. The MAXIM framework enables concurrent modeling of the hardware and software system aspects, avoiding the need to make the painful and information‐leaking transition from the abstract, qualitative conceptual system architecting stage to the concrete, detailed, quantitative design stage. The MAXIM environment aims to overcome the widening hardware‐software modeling gap, stepping toward bringing systems engineering and software engineering closer together. OPCloud is revolutionary in that it is the first and only modeling environment that enables modeling systems not just conceptually; the same environment also provides the modeler with the ability to proceed with detailed, quantitative design that is integrated into the qualitative model. The chapter discusses the sharing of model data and describes collaboration facilities as built into OPCloud.
The complexity of heterogeneous Multi-Processor Systems-on-Chip stretches the limits of software development solutions based on sequential languages such as C/C++. While these are still the most widely used languages in practice, model-based solutions appear to be an efficient alternative. However, the optimized compilation of models for multi-processor systems still presents many open research problems. Among others, static data-flow analyses for models require the adaptation of traditional algorithms used in program analysis (iterative and worklist algorithms). These algorithms operate on Control-Flow Graphs with a unique start node (i.e., a node without predecessors) and assume that every basic block is reachable from this start node. In this paper, we present a novel combination of the well-known iterative and worklist algorithms that examines a Control-Flow Graph where basic blocks can be reached by paths that originate from different start states. We apply this solution to functional views of signal and image processing models denoted with UML Activity and SysML Block diagrams. We demonstrate its effectiveness on interval analysis and show that significant reductions in the number of visits of the models’ control-flow graphs can be achieved.
This habilitation thesis deals with leveraging conceptualisation for harmonising software en-
gineering in the context of enterprise engineering. It is based on the research and work done
in the Centre of Conceptual Modelling and Implementation (CCMi) at the Department
of Software Engineering since its foundation by the author in 2012. Theoretical founda-
tions and key methodologies are introduced. Past and ongoing research and applications
based on them are then elaborated on; These consist of several layers: (i) Methodological
Studies, (ii) Methodological Improvements, (iii) Tooling and (iv) Applications. Achieved
results at the levels of bachelor and diploma theses, Ph.D. and post-doc research projects
are discussed. Key international collaborations, both academic and from practice are also
explained. The core of the thesis then consists of chapters being key already-published,
peer-reviewed publications.
The coming years will change the way we engineer and operate software-systems. On the one hand, the dependency of the society on software is rising fast. On the other hand, the systems become more and more complicated, autonomous, and artificially intelligent, thus generating increased risks. The methods, processes, and technologies of systems engineering will have to cope with these challenges in order to build sustainable, dependable software. This chapter describes some of the likely influences on the software of the future.
Web applications have several characteristics that differentiate them from conventional applications. However, they are often developed without considering such characteristics, even though there are specific methods for the design of these applications. This work proposes the combined use of the OOHDM method and executable models in an integrated environment for the model-driven development of Web applications. This environment provides a DSML for navigation modeling using the notations of the OOHDM and automatically generates the corresponding executable model, which permits simulating and testing this navigation without the need of code generation. It allows developers addressing specific aspects of web applications, such as hypertext, and identifying and fixing design problems beforehand via model execution.
In the rapid development of technology and the increasing speed of information flow due to globalization, making the role of information is vital and crucial to an educational institution. Institutions of Sunan Pandanaran implement policies of separate education system among male students with female students. This triggered a few problems, especially in the Senior high school of Sunan Pandanaran where researched by the author. The focus of the research is how to implement thearchitecture of Representational State Transfer (REST) on the integrated system academic information between two separate data server so that student academic data can be served easily from two different servers. Through the system resulting from this research, researchers offered easy access to student academic data that can then be recycled by the user into a useful information. The research methodology where used in this research is system development. The steps begin with a preliminary study research,data collection, design models, identifying system requirements and system development methods.
At the end, this research produced a integrated academic system information between male school servers with a female school server where implemented using Representational State Transfer architecture. So that student academic data can be presented either to the user in order to be recycled into useful information.
This habilitation thesis deals with leveraging conceptualisation for harmonising software en-
gineering in the context of enterprise engineering. It is based on the research and work done
in the Centre of Conceptual Modelling and Implementation (CCMi) at the Department
of Software Engineering since its foundation by the author in 2012. Theoretical founda-
tions and key methodologies are introduced. Past and ongoing research and applications
based on them are then elaborated on; These consist of several layers: (i) Methodological
Studies, (ii) Methodological Improvements, (iii) Tooling and (iv) Applications. Achieved
results at the levels of bachelor and diploma theses, Ph.D. and post-doc research projects
are discussed. Key international collaborations, both academic and from practice are also
explained. The core of the thesis then consists of chapters being key already-published,
peer-reviewed publications.
UML et OCL sont des standards pour la modélisation des systèmes informatiques et la spécication de leurs propriétés. Ils sont largement exploités dans les ateliers de génie logiciel parallèlement avec des techniques MDE (Model Driven Engineering) pour la génération systématique du code exécutable. Cependant, le reproche qui peut être fait à UML réside dans l'absence de bases permettant l'application des techniques de vérications formelles. De même,le langage OCL, bien que permettant une description formelle des propriétés d'un modèle UML,ne dispose pas d'outils pour la vérication et la preuve de ses propriétés. C'est pourquoi des méthodes formelles ont largement été utilisées pour la formalisation, l'analyse et la vérication des modèles UML/OCL, mais en raison de l'écart important entre UML et les méthodes formelles utilisées, plusieurs fonctionnalités UML/OCL sont ignorées, notamment l'héritage multiple, la dérivation des classes liées à partir des classes paramétrées et la propagation des contraintes OCL à travers ces fonctionnalités. Dans ce travail de thèse, nous proposons une formalisation des modèles UML/OCL supportant la plupart des fonctionnalités architecturales et conceptuelles d'UML/OCL, en utilisant le langage FoCaLiZe, un environnement de développement orienté objet et de programmation certiée, utilisant une approche basée preuve. Plus précisément, nous proposons une transformation formelle des modèles UML/OCL composés de diagrammes de classes, de diagrammes d'états-transitions et de contraintes OCL en spécication FoCaLiZe. Comme application directenous avons pu proposer un framework MDE, intégrant UML/OCL, FoCaLiZe et les règles de transformations proposées, et assistant l'utilisateur en cas d'erreur.
After thirty years, it is reasonably time to critically look at Model Driven Software Development (MDSD). Who may nowadays claim that MDSD has been massively adopted by the software industry? Who may show numbers demonstrating that MDSD allowed/allows massive cost savings in daily software development, but, above all, software maintenance? This paper aims at investigating executable modeling as a balanced articulation between programming and modeling. Models at run-time embody the promising generation of executable models, provided that their usages are thought and intended to cost-effective software development. To envisage this not-yet-come success, this paper emphasizes expectations from the software industry about “reactive programming”. Practically, executable modeling standards like the SCXML W3C standard or the BPMN OMG standard are relevant supports for reactive programming, but success conditions still need to be defined.
The complexity of today’s multi-processor architectures raises the need to increase the level of abstraction of software development paradigms above third-generation programming languages (e.g., C/C++). Code generation from model-based specifications is considered as a promising approach to increase the productivity and quality of software development, with respect to traditional paradigms where code is used as the main artifact to develop software. In this context, powerful and robust tools are needed in order to accomplish the transition from code-based programming to model-based programming. In this paper we propose a novel approach and tools where system-level models are compiled into standard C code while optimizing the system’s memory footprint. We show the effectiveness of our approach with the model-based programming of UML/SysML diagrams for a 5G decoder. From the compiled C code, we generate both a software implementation for a Digital Signal Processor platform and a hardware-software implementation for a platform based on hardware Intellectual Property (IP) blocks. Our optimizations achieve a memory footprint reduction of 80.07% and 88.93%, respectively.
ResearchGate has not been able to resolve any references for this publication.