Model-Based Engineering for the support of Models of Computation: The Cometa Approach

The development of Real-Time Embedded Systems (RTES) increasingly requires the integration of several parts with different purposes. Consequently, the heterogeneous appearance of such systems creates a need to manage their growing complexity mainly due to the difficulty to interconnect the different parts composing them. Model-Based Engineering (MBE) has significantly participated in recent decades to find solutions in terms of methodologies and technical support tailored to the design of RTES. Indeed, several models are used to represent different aspects of the system. However, the interconnection of different modeling paradigms is still a difficult challenge. The handling of such problems requires a clear definition of the execution and interconnection semantics of the different models composing the system. Indeed, the abstraction of the execution semantics of machines or Models of Computation (MoC) can highlight properties for the whole system’s execution. In this paper, we propose an approach that captures these semantics at the earliest modeling phases with the aim of exhibiting properties that ease the design space exploration and performance analysis of systems. Our approach extends the Modeling and Analysis of Real-Time Embedded Systems profile (MARTE) by providing means to express communication semantics of models. We also review existing approaches for defining such execution semantics

Teaching programming with computational and informational thinking

Computers are the dominant technology of the early 21st century: pretty well all aspects of economic, social and personal life are now unthinkable without them. In turn, computer hardware is controlled by software, that is, codes written in programming languages. Programming, the construction of software, is thus a fundamental activity, in which millions of people are engaged worldwide, and the teaching of programming is long established in international secondary and higher education. Yet, going on 70 years after the first computers were built, there is no well-established pedagogy for teaching programming. There has certainly been no shortage of approaches. However, these have often been driven by fashion, an enthusiastic amateurism or a wish to follow best industrial practice, which, while appropriate for mature professionals, is poorly suited to novice programmers. Much of the difficulty lies in the very close relationship between problem solving and programming. Once a problem is well characterised it is relatively straightforward to realise a solution in software. However, teaching problem solving is, if anything, less well understood than teaching programming. Problem solving seems to be a creative, holistic, dialectical, multi-dimensional, iterative process. While there are well established techniques for analysing problems, arbitrary problems cannot be solved by rote, by mechanically applying techniques in some prescribed linear order. Furthermore, historically, approaches to teaching programming have failed to account for this complexity in problem solving, focusing strongly on programming itself and, if at all, only partially and superficially exploring problem solving. Recently, an integrated approach to problem solving and programming called Computational Thinking (CT) (Wing, 2006) has gained considerable currency. CT has the enormous advantage over prior approaches of strongly emphasising problem solving and of making explicit core techniques. Nonetheless, there is still a tendency to view CT as prescriptive rather than creative, engendering scholastic arguments about the nature and status of CT techniques. Programming at heart is concerned with processing information but many accounts of CT emphasise processing over information rather than seeing then as intimately related. In this paper, while acknowledging and building on the strengths of CT, I argue that understanding the form and structure of information should be primary in any pedagogy of programming

Approaches Regarding Business Logic Modeling in Service Oriented Architecture

As part of the Service Oriented Computing (SOC), Service Oriented Architecture (SOA) is a technology that has been developing for almost a decade and during this time there have been published many studies, papers and surveys that are referring to the advantages of projects using it. In this article we discuss some ways of using SOA in the business environment, as a result of the need to reengineer the internal business processes with the scope of moving forward towards providing and using standardized services and achieving enterprise interoperability.Business Rules, Business Processes, SOA, BPM, BRM, Semantic Web, Semantic Interoperability

Design of Transmission Pipeline Modeling Language

General purpose software design and development involves the repetition of many processes, and the ability to automate these processes is often desired. To formalize a software process, such as modelling pipeline systems that transport fluids, an existing general purpose programming language (GPL) can be extended with its important aspects extracted as a model. However, the complexities and boundaries the programming language places on the ability to concisely and clearly describe the designing and modelling processes of the pipeline configurations can be difficult. The reality is that the library of a typical GPL Application Programmers Interface (API) constitutes class, method, and function names that become available only by object creation and method invocation, and as such cannot express domain concepts effectively. An alternative approach is to develop a language specifically for describing the processes. A language formalism that encourages domain specific development and as a tool for solving the complex problem of efficiently and effectively aiding the pipeline engineer in the design and implementation of pipeline configurations is presented in this paper. The language tool is used on the .Net platform for domain specific software development

A cloud-based integration platform for enterprise application integration: A Model-Driven Engineering approach

This article addresses major information systems integration problems, approaches, technologies, and tools within the context of Model-Driven Software Engineering. The Guaraná integration platform is introduced as an innovative platform amongst state-of-the-art technologies available for enterprises to design and implement integration solutions. In this article, we present its domain-specificmodeling language and its industrial cloud-based web development platform, which supports the design and implementation of integration solutions. A real-world case study is described and analyzed; then, we delve into its design and implementation, to finally disclose ten measures that empirically help estimating the amount of effort involved in the development of integration solutions

Action semantics of unified modeling language

The Uni ed Modeling Language or UML, as a visual and general purpose modeling language, has been around for more than a decade, gaining increasingly wide application and becoming the de-facto industrial standard for modeling software systems. However, the dynamic semantics of UML behaviours are only described in natural languages. Speci cation in natural languages inevitably involves vagueness, lacks reasonability and discourages mechanical language implementation. Such semi-formality of UML causes wide concern for researchers, including us. The formal semantics of UML demands more readability and extensibility due to its fast evolution and a wider range of users. Therefore we adopt Action Semantics (AS), mainly created by Peter Mosses, to formalize the dynamic semantics of UML, because AS can satisfy these needs advantageously compared to other frameworks. Instead of de ning UML directly, we design an action language, called ALx, and use it as the intermediary between a typical executable UML and its action semantics. ALx is highly heterogeneous, combining the features of Object Oriented Programming Languages, Object Query Languages, Model Description Languages and more complex behaviours like state machines. Adopting AS to formalize such a heterogeneous language is in turn of signi cance in exploring the adequacy and applicability of AS. In order to give assurance of the validity of the action semantics of ALx, a prototype ALx-to-Java translator is implemented, underpinned by our formal semantic description of the action language and using the Model Driven Approach (MDA). We argue that MDA is a feasible way of implementing this source-to-source language translator because the cornerstone of MDA, UML, is adequate to specify the static aspect of programming languages, and MDA provides executable transformation languages to model mapping rules between languages. We also construct a translator using a commonly-used conventional approach, in i which a tool is employed to generate the lexical scanner and the parser, and then other components including the type checker, symbol table constructor, intermediate representation producer and code generator, are coded manually. Then we compare the conventional approach with the MDA. The result shows that MDA has advantages over the conventional method in the aspect of code quality but is inferior to the latter in terms of system performance

Secure Virtualization and Multicore Platforms State-of-the-Art report

SVaM