Search

We present PrintTalk, a DSL to "program" 3D objects, called "gadgets". PrintTalk also features "topologies", which are predefined spacial arrangements of gadgets. Gadgets are composed by executing a gadget script (possibly consisting of subscripts) that 'draws' the gadget in the 3D scene. However, executing the script also returns a number of constraint variables. These variables can be constrained inside the gadget and can also be bound outside the gadget in order to constrain the produced gadgets after the facts. This is the essence of the gadget composition mechanism of PrintTalk. PrintTalk is implemented in DrRacket. Running a PrintTalk program generates a file that is sent to the 3D printer. We validate PrintTalk qualitatively by comparing the code for complex gadgets with the code needed to print those gadgets in existing languages.

Agent-based simulations represent an effective scientific tool, with numerous applications from social sciences to biology, which aims to emulate or predict complex phenomena through a set of simple rules performed by multiple agents. To simulate a large number of agents with complex models, practitioners have developed high-performance parallel implementations, often specialized for particular scenarios and target hardware. It is, however, difficult to obtain portable simulations, which achieve high performance and at the same time are easy to write and to reproduce on different hardware. This article gives a complete presentation of OpenABL , a domain-specific language and a compiler for agent-based simulations that enable users to achieve high-performance parallel and distributed agent simulations with a simple and portable programming environment. OpenABL is comprised of (1) an easy-to-program language, which relies on domain abstractions and explicitly exposes agent parallelism, synchronization and locality, (2) a source-to-source compiler, and (3) a set of pluggable compiler backends, which generate target code for multi-core CPUs, GPUs, and cloud-based systems. We evaluate OpenABL on simulations from different fields. In particular, our analysis includes predator–prey and keratinocyte, two complex simulations with multiple step functions, heterogeneous agent types, and dynamic creation and removal of agents. The results show that OpenABL -generated codes are portable to different platforms, perform similarly to manual target-specific implementations, and require significantly fewer lines of codes.

In recent years, the number of smartphone users has increased dramatically. These users download millions of apps and use them for various services. Due to the significant demand for mobile apps, developers often seek faster development methods and more effective tools and techniques to generate these apps. Many of these apps are location-based apps in which users receive services based on their geographical location. In this paper, we propose a model-driven approach for the automatic generation of Android location-based mobile apps. Our framework, called ALBA, consists of a domain-specific modeling language, a modeling tool, and a plugin which includes model to code transformations. The modeling tool enables a novice designer to model a location-based app. The model is validated against the predefined constraints and the editor prevents creating invalid models. The designer uses the plugin to generate the Android code of the app. The evaluation of our work is two fold. First, to evaluate the generalizability of the ALBA framework, we conducted an experiment which includes the generation of four industrial location-based apps. Second, to evaluate the usability and quality of both the framework and the generated apps, we conducted a case study consists of three experiments. The results of the evaluation are promising both in terms of the applicability of the framework and the quality of the generated apps.

At 2000 m depth in the oceans, one can hear biological, seismological, meteorological, and anthropogenic activity. Acoustic monitoring of the oceans at a global scale and over long periods of time could bring important information for various sciences. The Argo project monitors the physical properties of the oceans with autonomous floats, some of which are also equipped with a hydrophone. These have a limited transmission bandwidth requiring acoustic data to be processed on board. However, developing signal processing algorithms for these instruments requires one to be an expert in embedded software. To reduce the need of such expertise, we have developed a programming language, called MeLa. The language hides several aspects of embedded software with specialized programming concepts. It uses models to compute energy consumption, processor usage, and data transmission costs early during the development of applications, this helps to choose a strategy of data processing that has a minimum impact on performances. Simulations on a computer allow for verifying the performance of the algorithms before their deployment on the instrument. We have implemented a seismic P wave detection and a blue whales D call detection algorithm with the MeLa language to show its capabilities. These are the first efforts toward multidisciplinary monitoring of the oceans, which can extend beyond acoustic applications.

Service robots, a type of robots that perform useful tasks for humans, are foreseen to be broadly used in the near future in both social and industrial scenarios. Those robots will be required to operate in dynamic environments, collaborating among them or with users. Specifying the list of requested tasks to be achieved by a robotic team is far from being trivial. Therefore, mission specification languages and tools need to be expressive enough to allow the specification of complex missions (e.g., detailing recovery actions), while being reachable by domain experts who might not be knowledgeable of programming languages. To support domain experts, we developed PROMISE, a Domain-Specific Language that allows mission specification for multiple robots in a user-friendly, yet rigorous manner. PROMISE is built as an Eclipse plugin that provides a textual and a graphical interface for mission specification. Our tool is in turn integrated into a software framework, which provides functionalities as: (1) automatic generation from specification, (2) sending of missions to the robotic team; and (3) interpretation and management of missions during execution time. PROMISE and its framework implementation have been validated through simulation and real-world experiments with four different robotic models. Video: https://youtu.be/RMtqwY2GOlQ

Funding: Adaptive Brokerage for the Cloud (ABC) project, UK EPSRC grants EP/R010889/1 and EP/R010528/1. The current large selection of cloud instances that are functionally equivalent makes selecting the right cloud service a challenging decision. We envision a model driven engineering (MDE) approach to raise the level of abstraction for cloud service selection. One way to achieve this is through a domain specific language (DSL) for modelling the service level objectives (SLOs) and a brokerage system that utilises the SLO model to select services. However, this demands an understanding of the provider SLAs and the capabilities of the current cloud modelling languages (CMLs). This paper investigates the state-of-the-art for SLO support in both cloud providers SLAs and CMLs in order to identify the gaps for SLO support. We then outline research directions towards achieving the MDE-based cloud brokerage. Postprint

Product Derivation represents one of the main challenges that Software Product Line (SPL) faces. Deriving individual products from shared software assets is a time-consuming and an expensive activity. In this paper, we (1) present an MDE approach for engineering SPL and (2) propose to leverage model-to-model transformations (MMT) and model-to-text (MTT) transformations for supporting both domain engineering and application engineering processes. In this work, we use ATL as a model-to-model transformation language and Acceleo as a model-to-text transformation language.The proposed approach is discussed with e-Health product line applications.

Runtime verification (RV) is an approach to verification consisting in dynamically checking that the event traces generated by single runs of a system under scrutiny (SUS) are compliant with the formal specification of its expected correct behavior. RML (Runtime Monitoring Language) is a simple but powerful Domain Specific Language (DSL) for RV which is able to express non context-free properties. When designing RML, particular care has been taken to favor abstraction and simplicity, to better support reusability and portability of specifications and interoperability of the monitors generated from them; this is mainly achieved by decoupling the two problems of property specification and event generation, and by minimizing the available primitive constructs. The formalization and implementation of RML is based on a trace calculus with a fully deterministic rewriting semantics. The semantics of RML is defined by translation into such a calculus, which, in fact, is used as intermediate representation (IR) by the RML compiler. The effectiveness of RML and its methodological impact on RV are presented through interesting patterns that can be adapted to different contexts requiring verification of standard properties. A collection of tested examples is provided, together with benchmarks showing that the deterministic semantics and the performed dynamic optimizations based on the laws of the trace calculus significantly improve the performances of the generated monitors.

ISBN 979-10-97-498-01-6. A post-proceeding version is planed at LNCS Springer. The proceedings are available at URL: https://cmmr2019.prism.cnrs.fr/Docs/Proceedings_CMMR2019.pdf; International audience; Different programming systems for computer music are based upon seemingly similar, but profoundly different, programming paradigms. In this paper, we shall discuss some of them, with particular reference to computer-aided composition systems and Max. We shall subsequently show how the bach library can support different programming styles within Max, improving the expression, the readability and the maintainance of complex algorithms. In particular, the forthcoming version of bach introduces bell, a small textual programming language embedded in Max and specifically designed to facilite programming tasks related to manipulation of symbolic musical material.

International audience; Monitoring of the oceans with autonomous floats is of great interest for many disciplines. Monitoring on a global scale needs a multidisciplinary approach to be affordable. For this purpose, we propose an approach that allows oceanographers from different specialities to develop applications for autonomous floats. However, developing such applications usually requires expertise in embedded systems, and they must be reliable and efficient with regards to the limited resources of the floats (e.g., energy, processing power). We have followed a Model Driven Engineering approach composed of i) a Domain Specific Language to allow oceanographers to develop applications, ii) analysis tools to ensure that applications are efficient and reliable, iii) a composition tool to allow the deployment of different applications on a same float, and iv) a code generator that produce efficient and reliable code for the float. We present our approach with a biological and a seismological application. We validate it with technical metrics and an experiment.

A good virtual Learning Space (LS) should convey pertinent learning information to the visitors at the most adequate time and locations to favor their knowledge acquisition.Considering the consolidation of the internet and the improvement of the interaction, searching, and learning mechanisms, we propose a generic architecture, called CaVa, to create virtual Learning Spaces building up on cultural institution documents. More precisely, our proposal is to automatically create ontology-based virtual learning environments.Thus, to impart relevant learning materials to the virtual LS, we propose the use of ontologies to represent the key concepts and semantic relations in an user- and machine-understandable format. These concepts together with the data (extracted from the real documents) stored in a digital storage format (XML datasets, relational databases, etc.) are displayed in an ontology-based learning space that enables the visitors to use the available features and tools to learn about a specific domain.According to the approach here discussed, each desired virtual LS must be specified rigorously through a domain specific language (DSL) that was designed and implemented.To validate the proposed architecture, three case studies will be used as instances of CaVa architecture.

Nowadays, it is a modern trend to develop a CASE tool for system modelling with an ability to transform models defined in different notations and also to generate a program code. However development of such a tool often involves experimentation with transformation algorithms that may require changes to the source model structure. Since CASE tools are basically used to represent a model in diagram’s form, implementing experimental changes in a modelling tool can require additional effort. In order to solve this problem, authors propose a way of describing the two-hemisphere model using Domain Specific Language. This paper covers the language’s syntax as well as provides an example of the two-hemisphere model defined with its help.

International audience; Field Programmable Gate Array (FPGA) architec-tures are suitable hardware platforms for systems that need high performance and flexibility, because they support dynamic partial reconfiguration (DPR) to implement adaptive hardware algorithms e.g., for performance or energy efficiency. They are used for example in embedded systems such as UAV, e.g. for video processing. It is a challenge to design Autonomic Managers for such highly dynamic systems, taking into account the combina-torial design space of configurations and criteria and policies to decide on whether to reconfigure, and what next configuration to choose. In this paper, we propose a Domain Specific Language (DSL) called Ctrl-DPR, allowing designers to easily generate Autonomic Managers. They can describe their system and their management strategies, in terms of the entities composing the system : tasks, versions, applications, ressources, policies. The DSL relies on a behavioural modelling of these entities, targeted at the design of autonomic managers to control the reconfigurations in such a way as to enforce given policies and strategies. The models we use involve automata to describe the state space of configurations, and the transitions representing reconfigurations; they also involve discrete control techniques exploiting such models in order to obtain a correct runtime manager. These model-based control techniques are embedded in a compiler, connected to a reactive language and discrete controller synthesis tool, which enables to generate a C implementation of the controller enforcing the management strategies. We apply our DSL for the management of a video application on a UAV.

When implementing a programming language, we often write a parser and a pretty-printer. However, manually writing both programs is not only tedious but also error-prone; it may happen that a pretty-printed result is not correctly parsed. In this paper, we propose FliPpr, which is a program transformation system that uses program inversion to produce a CFG parser from a pretty-printer. This novel approach has the advantages of fine-grained control over pretty-printing, and easy reuse of existing efficient pretty-printer and parser implementations.

Cyber-physical systems consist of many hardware and software components. Over the life-cycle of these systems, components are replaced or updated. To avoid integration problems, good interface descriptions are crucial for component-based development of these systems. For new components, a Domain Specific Language called Component Modeling Analysis can be used to formally define the interface of such a component in terms of its signature, state and timing behavior. Having interfaces described in a model-based approach enables the generation of artifacts, for instance, to generate a monitor that can check interface conformance of components based on a trace of observed interface interactions during execution. The benefit of having formal interface descriptions also holds for legacy system components. Interfaces of legacy components can be reverse engineered manually. In order to reduce the manual effort, we present an automated learner. The learner can reverse engineer state and timing behavior of a legacy interface by examining event traces of the component in operation. The learner will then generate a ComMA model. © 2018 Polish Information Processing Society.

Combinatorial Interaction Testing (CIT) is an effective technique that, however, requires a good tool support in order to be successfully applied. There are several tools and applications for CIT, and most of them are distributed as desktop applications or as special plugins of existing programs and require some installation procedures to be used. Software as a Service (SaaS) paradigm can be applied to CIT modeling and test generation, proving several advantages to the tester. There are already some attempts in this direction, but with some shortcomings (little editing support, for example). In this paper, we present CTWEDGE (Combinatorial Testing Web EDiting and GEneration), which defines a language for CIT models in the presence of constraints by using Xtext. It introduces a web service for editing CIT specifications and it interfaces, through a server, with other tools for test generation. CTWEDGE can improve the user experience by providing a complete environment for CIT modeling and generation on the web without sacrificing usability.

We propose a new DSL and separation-based architecture and development methodology.The approach separates front-end UI concerns from back-end implementation concerns.A climate science application illustrates the approach and verifies its validity.Evaluation of the approach includes comparative analysis and usability studies.The approach increases developer productivity and enhances UI design flexibility. This paper proposes an architecture and associated methodology to separate front end UI concerns from back end coding concerns to improve the platform flexibility, shorten the development time, and increase the productivity of developers. Typical UI development is heavily dependent upon the underlying platform, framework, or tool used to create it, which results in a number of problems. We took a separation-based UI architecture and modified it with a domain specific language to support the independence of UI creation thereby resolving some of the aforementioned problems. A methodology incorporating this architecture into the development process is proposed. A climate science application was created to verify the validity of the methodology using modern practices of UX, DSLs, code generation, and model-driven engineering. Analyzing related work provides an overview of other methods similar to our method. Subsequently we evaluate the climate science application, conclude, and detail future work.

Web services composition is a recurring idea in the field of smart residential environments (SRE), since it helps to solve complex problems such as energy saving, security control or health care by combining and orchestrating the available basic services. Smart environments are composed of networked devices (sensors and actuators) embedded within web services, which contain well-defined programming interfaces allowing them to share data, capture events and create composed control applications. There is still, however, a lack of domain specific languages (DSL) supporting a high degree of abstraction and transparency and allowing users to define control scenarios in a compact and comprehensible way. To satisfy these needs, the present paper aims to propose a DSL for describing scenarios to control SRE, with considerable gains in transparency, abstraction, expressiveness and simplicity.

The article presents tCF (testCaseFramework) - a domain specific language with corresponding toolchain for specification-based software testing of embedded software. tCF is designed for efficient preparation of maintainable and intelligible test cases and for testing process automation, as it allows to generate platform specific test cases for various testing levels. The article describes the essential parts of the tCF meta-model and the applied concept of platform specific test cases generators.

International audience; Artifacts not only combine data and process into the same semantic entities that evolve according to precise state-based lifecycles, but they also provide casual users with a simple and intuitive framework for modeling, exe- cuting, and managing business processes. Despite the surge in interest, artifacts still lack effective languages and tools to define, manipulate and interrogate their instances. Most existing artifact languages and notations focuses only on modeling and executing artifact-based processes in which data have discrete values and fail to handle artifacts in which their data include continuous data streams. In this paper, we present the Continuous Artifact Query Language (CAQL) for modeling stream-based artifacts and semantically manipulating and interrogating their instances.

Part 4: Engineering of Enterprise Software Products; International audience; Hierarchical Data Format (HDF5) is a popular binary storage solution in high performance computing (HPC) and other scientific fields. It has bindings for many popular programming languages, including C++, which is widely used in the HPC field. Its C++ API requires mapping of the native C++ data types to types native to the HDF5 API. This task can be error prone, especially when working with complex data structures, which are usually stored using HDF5 compound data types. Due to the lack of a comprehensive reflection mechanism in C++, the mapping code for data manipulation has to be hand-written for each compound type separately. This approach is vulnerable to bugs and mistakes, which can be eliminated by using an automated code generation phase. In this paper we present an approach implemented in the LARA language and supported by the tool Clava, which allows us to automate the generation of the HDF5 data access code for complex data structures in C++.

Unclear descriptions of software interfaces between components often lead to integration issues during development and maintenance. To address this, we have developed a framework named ComMA (Component Modeling and Analysis) that supports model-based engineering of components. ComMA is a combination of Domain Specific Languages (DSLs) for the specification of interface signatures, state machines to express the allowed interaction behaviour, and constraints on data and timing. From ComMA models a number of artefacts can be generated automatically such as proxy code, visualizations, tests, and simulation models. In this paper, the focus is on the generation of runtime monitors to check interface conformance, including the state machine behaviour and the specified data and time constraints. We report about the development of this approach in close collaboration with the development of medical applications at Philips.

International audience; Mostly the development of domain specific modeling languages (DSML) follows the traditional model driven engineering practices. First the syntax and semantics of the language are defined (at meta-level) and then it is used for the development of user models. In certain situations, it is hard even to conceptualize the demands of the user, let alone the definition of the language. Agile methods for software development suggest that the development activities should be performed alongside a client stakeholder for incremental development of the system. This approach helps in the elicitation of requirements in parallel to the actual development of the system. We followed this approach for developing a domain specific modeling language and its tooling for a local government project, Brest Métropole. The project aimed at filling the communication gap between the elected representatives (politicians) and the bureaucracy (government officers). We used a modeling methodology that does not restrict a modeler's interaction to a single abstraction level. Thus a modeler can develop both models and metamodels at the same time, where the definition of one helps in defining the other. In this article, we explain our experiences from this project and share the lessons learnt.

This paper summarizes a novel approach for consuming a domain specific language (DSL) by transforming it to a directed graph representation persisted by a graph database. Using such specialized database enables advanced navigation trough the stored model exposing only relevant subsets of meta-data to different involved services and components. We applied this approach in a mobile cloud computing system and used it to model several mobile applications in retail, supply chain management and merchandising domain. These application are distributed in a Software-as-a-Service (SaaS) fashion and used by thousands of customers in Croatia. We report on lessons learned and propose further research on this topic.

Two Domain Specific Languages (DSLs) have been developed to improve the development of a power control component of interventional X-ray systems of Philips. Configuration files and test cases are generated from instances of these DSLs. To increase the confidence in these instances and the generators, formal models have been generated to analyse DSL instances and to crosscheck the results of the generators. A DSL instance serves as a single source from which the implementation and the formal analysis models are generated. In this way, it is easy to maintain the formal support in case of changes and for new product releases. We report about our experiences with this approach in a real development project at Philips.

Parallelising sequential applications is usually a very hard job, due to many different ways in which an application can be parallelised and a large number of programming models (each with its own advantages and disadvantages) that can be used. In this paper, we describe a method to semi-automatically generate and evaluate different parallelisations of the same application, allowing programmers to find the best parallelisation without significant manual reengineering of the code. We describe a novel, high-level domain-specific language, Refactoring Pattern Language (RPL), that is used to represent the parallel structure of an application and to capture its extra-functional properties (such as service time). We then describe a set of RPL rewrite rules that can be used to generate alternative, but semantically equivalent, parallel structures (parallelisations) of the same application. We also describe the RPL Shell that can be used to evaluate these parallelisations, in terms of the desired extra-functional properties. Finally, we describe a set of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's source code, therefore giving a parallel version of the code. We demonstrate how the RPL and the refactoring rules can be used to derive efficient parallelisations of two realistic C++ use cases (Image Convolution and Ant Colony Optimisation).

Code Generation is an increasing popular technique for implementing Software Product Lines that produces code from abstract specifications written in Domain Specific Languages (DSLs). This paper proposes to take advantage of the similitude among the products in a domain to generate them by analogy. That is, instead of synthesizing the final code from scratch or transforming the DSL specifications, the final products are obtained by adapting a previously developed domain product. The paper also discusses the capabilities and limitations of several currently available tools and languages to implement this kind of generators and introduce a new language to overcome the limitations.

International audience; The field of synthetic biology is looking forward engineering framework for safely designing reliable de-novo biological functions. In this undertaking, Computer-Aided-Design (CAD) environments should play a central role for facilitating the design. Although, CAD environment is widely used to engineer artificial systems the application in synthetic biology is still in its infancy. In this article we address the problem of the design of a high level language which at the core of CAD environment. More specifically the Gubs (Genomic Unified Behavioural Specification) language is a specification language used to describe the observations of the expected behaviour. The compiler appropriately selects components such that the observation of the synthetic biological function resulting to their assembly complies to the programmed behaviour.

International audience; This work deals with parallelism in linear algebra routines. We propose a domain specific language based on C/C++ macros, PALADIn (Parallel Algebraic Linear Algebra Dedicated Interface). This domain specific language allows the user to write C++ code and benefit from sequential and parallel executions on shared memory architectures. With a unique syntax, the user can switch between different parallel runtime systems such as OpenMP, TBB and xKaapi. This interface provides data and task parallelism. Depending on the runtime system, task parallelism can use explicit synchronizations or data-dependency based synchronizations. Also, this language provides different matrix cutting strategies according to one or two dimensions. Moreover, block algorithms, such as block iterative and recursive matrix multiplication, can involve splitting according to three dimensions. The latter is also a feature that is provided to the user. The PALADIn interface can be used in any C++ library for linear algebra computation and gets the best performance from the three supported parallel runtime systems.

International audience; More and more requirements are given on the ability to precisely control at run time the achievement of a network and communicating systems monitoring activity. This paper gives an overview of AMSDL (Adaptive Monitoring Strategy Description Language), which is a language under development dedicated at the expression of adaptive monitoring strategies. AMSDL will provide both the network managers and the software developers of autonomic modules with the capacity to easily declare, more than the resources to be managed, the logics that will govern the dynamic monitoring behavior according to the variations of functional, informational and operational requirements.

International audience; The overall goal of our approach is to relate models of a given domain that are created by different actors and thus are generally heterogeneous that is, described in different DSL (Domain Specific Languages). Instead of building a single global model, we propose to organize the different source models as a network of models which provides a global view of the system through a virtual global model. The matching of these models is done in a shared model of correspondences. We focus in this study on the elaboration of the model of correspondences, through a transformation called "refine". The approach is illustrated by a representative use case (a Bug Tracking System) and supported by a modeling tool called HMS (Heterogeneous Matching Suite).

International audience; Constraint propagation is at the heart of constraint solvers. Two main trends co-exist for its implementation: variable-oriented propagation engines and constraint-oriented propagation engines. Those two approaches ensure the same level of local consistency but their efficiency (computation time) can be quite different depending on the instance solved. However, it is usually accepted that there is no best approach in general, and modern constraint solvers implement only one. In this paper, we would like to go a step further providing a solver independent language at the modeling stage to enable the design of propagation engines. We validate our proposal with a reference implementation based on the Choco solver and the MiniZinc constraint modeling language.

This paper introduces a system that offer a special big data analysis platform with Domain Specific Language for telecom industries. This platform has three main parts that suggests a new kind of domain specific system for processing and visualization of large data files for telecom organizations. These parts are Domain Specific Language (DSL), Parallel Processing/Analyzing Platform for Big Data and an Integrated Result Viewer. In addition to these main parts, Distributed File Descriptor (DFD) is designed for passing information between these modules and organizing communication. To find out benefits of this domain specific solution, standard framework of big data concept is examined carefully. Big data concept has special infrastructure and tools to perform for data storing, processing, analyzing operations. This infrastructure can be grouped as four different parts, these are infrastructure, programming models, high performance schema free databases, and processing-analyzing. Although there are lots of advantages of Big Data concept, it is still very difficult to manage these systems for many enterprises. Therefore, this study suggest a new higher level language, called as DSL which helps enterprises to process big data without writing any complex low level traditional parallel processing codes, a new kind of result viewer and this paper also presents a Big Data solution system that is called Petaminer.

We propose a novel high level programming notation, called FIDO, that we have designed to concisely express regular sets of strings or trees. In particular, it can be viewed as a domain-specific language for the expression of finite state automata on large alphabets (of sometimes astronomical size). FIDO is based on a combination of mathematical logic and programming language concepts. This combination shares no similarities with usual logic programming languages. FIDO compiles into finite state string or tree automata, so there is no concept of run-time. It has already been applied to a variety of problems of considerable complexity and practical interest. We motivate the need for a language like FIDO, and discuss our design and its implementation. Also, we briefly discuss design criteria for domain-specific languages that we have learned from the work with FIDO. We show how recursive data types, unification, implicit coercions, and subtyping can be merged with a variation of predicate logic, called the Monadic Second-order Logic (M2L) on trees. FIDO is translated first into pure M2L via suitable encodings, and finally into finite state automata through the MONA tool.

Date of Conference: September 29 – October 4, 2013 Conference name: International Conference on Model Driven Engineering Languages and Systems 16th International Conference, MODELS 2013 The trend from single processor to parallel computer architectures has increased the importance of parallel computing. To support parallel computing it is important to map parallel algorithms to a computing platform that consists of multiple parallel processing nodes. In general different alternative mappings can be defined that perform differently with respect to the quality requirements for power consumption, efficiency and memory usage. The mapping process can be carried out manually for platforms with a limited number of processing nodes. However, for exascale computing in which hundreds of thousands of processing nodes are applied, the mapping process soon becomes intractable. To assist the parallel computing engineer we provide a model-driven approach to analyze, model, and select feasible mappings. We describe the developed toolset that implements the corresponding approach together with the required metamodels and model transformations. We illustrate our approach for the well-known complete exchange algorithm in parallel computing. © 2013 Springer-Verlag.

International audience; It is typical in the domain of digital games to have many development problems due to its increasing complexity. Those difficulties include: i) little code reuse in order to develop a cross-platform game; and ii) performing game's verification through extensive and expensive tests. This of course results in low productivity in the development (evolution and maintenance) of game solutions. In this paper, we present a domain-specific language (DSL) for a Role-Playing Game (RPG) product lines, which was completely built using a software development technique driven by high level abstractions-called Model-Driven Development (MDD). Also, we discuss and demonstrate the several benefits of applying MDD in terms of rapid prototyping of cross-platform games, and their evaluation by means of static and dynamic verification of the game's logic properties.

Date of Conference: 16 - 20 July 2012 Conference name: Proceedings of the 6th ACM International Conference on Distributed Event-Based Systems, DEBS'12 At one level, this paper is about River, a virtual execution environment for stream processing. Stream processing is a paradigm well-suited for many modern data processing systems that ingest high-volume data streams from the real world, such as audio/video streaming, high-frequency trading, and security monitoring. One attractive property of stream processing is that it lends itself to parallelization on multicores, and even to distribution on clusters when extreme scale is required. Stream processing has been co-evolved by several communities, leading to diverse languages with similar core concepts. Providing a common execution environment reduces language development effort and increases portability. We designed River as a practical realization of Brooklet, a calculus for stream processing. So at another level, this paper is about a journey from theory (the calculus) to practice (the execution environment). The challenge is that, by definition, a calculus abstracts away all but the most central concepts. Hence, there are several research questions in concretizing the missing parts, not to mention a significant engineering effort in implementing them. But the effort is well worth it, because using a calculus as a foundation yields clear semantics and proven correctness results. Copyright © 2012 ACM.

The development of large and complex systems involves many people, stakeholders. Engineeringly speaking, one way to control this complexity is by designing and analyzing the system from different perspectives. For each perspective, stakeholders benefit from means, tools, languages, specific to their activity domain. A Domain Specific Language (DSL) per perspective is such a dedicated means. While DSLs are used for modeling, other means, tools, and languages are needed for other connected activities, like testing or collaborating. However, using such different types of tools together, integrating DSLs into stakeholders’ software process is not straightforward. In this chapter, the authors advance an integration process of DSLs with other tools. The chapter proposes each stakeholder have their own DSL with associated graphical editor, operational semantics, and generation of scripts for off the shelf simulators, e.g., testing. Additionally to the integrated stakeholders’ software process, the authors introduce a model driven process dedicated to the tool vendor which creates the DSLs and its associated tools. Due to the integration of DSLs into this process, they contend that stakeholders will significantly reduce system construction time. The chapter illustrates the two processes on Telecommunications service construction.

Developing reliable context-aware applications remains a big challenge, even after a decade of research in this area. Usually a lot of code is required to handle an application's correct behavior in a variety of different situations. Along with a growing amount of code, also increases the risk of programming errors that may lead to an undesired behavior in particular situations. In this paper we present a domain specific language (DSL) for developing context-aware applications. It allows creating context quality models which are transformed into software artifacts of the final application. This code generation saves time and effort, and helps to ensure an appropriate autonomic behavior at runtime in inherently uncertain situations. ispartof: pages:41-49 ispartof: Ambient Intelligence - Software and Applications: 2nd International Symposium on Ambient Intelligence (ISAmI 2011) vol:92 pages:41-49 ispartof: International Symposium on Ambient Intelligence location:Salamanca, Spain date:6 Apr - 8 Apr 2011 status: published

Regulatory compliance management is now widely recognized as one of the main challenges still to be efficiently dealt with in information systems. In the discipline of business process management in particular, compliance is considered as an important driver of the efficiency, reliability and market value of companies. It consists of ensuring that enterprise systems behave according to some guidance provided in the form of regulations. This paper gives a definition of the research problem of regulatory compliance. We show why we expect a formal policy-based and model-driven approach to provide significant advantages in allowing enterprises to flexibly manage decision-making related to regulatory compliance. For this purpose, we contribute CoReL, a domain-specific modeling language for representing compliance requirements that has a graphical concrete syntax. Informal semantics of CoReL are introduced and its use is illustrated on an example. CoReL allows to leverage business process compliance modeling and checking, enhancing it with regard to, among other dimensions, user-friendliness, genericity, and traceability.

This paper considers the problem of model-based testing of a class of safety-critical systems. These systems are built up from components that are connected a network-like structure. The number of possible structures is usually large. In particular, we consider the following issue: For many of these systems, each instance needs its own set of models for testing. On the other hand, the instances that should be tested will have to be chosen so that the reliability statements are generally applicable. Thus, they must be chosen by a domain expert. The approach in this paper addresses both of these points. The structure of the instance of system under test is described using a domain-specific language, so that a domain expert can easily describe a system instance for testing. At the same time, the components and composition operators are formalized. Using a structure description written in the DSL, corresponding test models can be automatically generated, allowing for automated testing by the domain expert. We show some evidence about the feasibility of our approach and about the effort required for modelling an example, supporting our belief that our approach improves both on the efficiency and the expressivity of current compositional test model construction techniques.

La construcción de sistemas colaborativos con awareness es una tarea muy compleja. En este trabajo se define el lenguaje específico de dominio CSSL v2.0 - Collaborative Software System Language - construido como extensión de UML, usando el mecanismo de metamodelado. Se analiza la simplicidad, expresividad y precisión del lenguaje para modelar los conceptos principales de estos sistemas, especialmente los procesos colaborativos, protocolos y awareness. A partir de casos de modelado se muestra una sintaxis concreta implementada a través de editores gráficos que permiten construir modelos de sistemas colaborativos. Estos son independientes de la plataforma de implementación y están formalmente preparados para ser derivados en implementaciones concretas aplicando transformaciones utilizando el paradigma MDD (Model Driven Development). Las transformaciones de modelo a texto generan versiones Web implementadas con tecnologías JavaScript, MongoDB y Websockets que brindan un conjunto de funcionalidad básica que los desarrolladores pueden refinar para completar la implementación de los sistemas colaborativos con awareness. Finalmente se realiza una evaluación, validación y verificación del metamodelo que finalizan con la comprobación que comprueban que el lenguaje CSSL v2.0, permite definir de forma precisa, concisa y amigable los conceptos abstractos de los sistemas colaborativos, incluyendo los procesos colaborativos, protocolos y awareness, lo cual representa un avance al estado actual de estas tecnologías., Building Collaborative systems with awareness (or groupware) is a very complex task. This thesis presents the design and implementation of the domain specific language CSSL v2.0 - Collaborative Software System Language -built as an extension of UML, using the metamodeling mechanism. CSSL provides simplicity, expressiveness and precision to model the main concepts of collaborative systems, especially collaborative processes, protocols and awareness. The CSSL concrete syntax is defined via a set of editors through which collaborative systems models are created. According to the MDD methodology, models are independent of the implementation platform and are formally prepared to be transformed. The target of the transformation is a web application based on JavaScript, MongoDB and Websockets technology, that provides a set of basic functions that developers can refine to complete the development of the collaborative system. Finally, evaluation, validation and verification of the language is performed, determining that the CSSL tools allow developers to solve central aspects of collaborative systems implementation in a simple and reasonable way, representing an advance to the current state of these technologies., Facultad de Informática

Program domain concepts are rather complex and low level for a fast assimilation. On the other hand, problem domain concepts are closer to human’s mind, hence they are easier to perceive. Based on Brook’s theory, a full comprehension of a program is only achieved if both domains are connected and visualized in synchronization, resulting on an action-effect visualization. Domain-specific languages, as languages tailored for a specific class of problems, raise the abstraction of the program domain concepts and approximate them to the problem domain’s. This way, a systematic approach can be used to perform the action-effect visualization of a program written in a domain-specific language. In this paper, we use a domain-specific language to exemplify how the concepts involved in both domains are visualized and how it is possible to map each problem domain situation (depicted by images) to the program domain operations. CCTC - Universidade do Minho

International audience; To keep up with the frantic pace at which devices come out, drivers need to be quickly developed, debugged and tested. We have recently introduced a new approach to improve driver robustness based on an Interface Definition Language, named Devil. Devil allows a high-level definition of the communication of a device. A compiler automatically checks the consistency of a Devil specification and generates stubs that include run-time checks. In this paper, we use mutation analysis to evaluate the improvement in driver robustness offered by Devil. To do so, we have injected programming errors using mutation analyses into Devil based Linux drivers and the original C drivers. We assess how early errors can be caught in the development process, by measuring whether errors are detected either at compile time or at run time. The results of our experiments on the IDE Linux disk driver show that nearly 3 times more errors are detected in the Devil driver than in the original C driver.

Modern IDEs increase developer productivity by incorporating many different kinds of editor services. These can be purely syntactic, such as syntax highlighting, code folding, and an outline for navigation; or they can be based on the language semantics, such as in-line type error reporting and resolving identifier declarations. Building all these services from scratch requires both the extensive knowledge of the sometimes complicated and highly interdependent APIs and extension mechanisms of an IDE framework, and an in-depth understanding of the structure and semantics of the targeted language. This paper describes Spoofax/IMP, a meta-tooling suite that provides high-level domain-specific languages for describing editor services, relieving editor developers from much of the framework-specific programming. Editor services are defined as composable modules of rules coupled to a modular SDF grammar. The composability provided by the SGLR parser and the declaratively defined services allows embedded languages and language extensions to be easily formulated as additional rules extending an existing language definition. The service definitions are used to generate Eclipse editor plugins. We discuss two examples: an editor plugin for WebDSL, a domain-specific language for web applications, and the embedding of WebDSL in Stratego, used for expressing the (static) semantic rules of WebDSL. publishedVersion

Nowadays, in residential environments context, an increasing number of connected devices and objects (that fall broadly into two categories: actuators and sensors) provide useful functionalities and services to improve urban living conditions. These devices and their associated services, however, cannot be easily integrated to create new composite applications, such as controlling different home devices for saving energy or enhancing user comfort. In order to meet this requirement, we propose a domain ontology to discover, search, use and share information and services of residential environment devices. This ontology forms the central part of our proposed application development framework. In this paper, we briefly introduce this ontology and explain, through examples, how it is used during the different steps of an application development process.

The use of software patterns is a common practice in software design, providing reusable solutions for recurring problems. Patterns represent a general skeleton used to solve common problems, providing a way to share regular practices and reduce the resources needed for implementing software systems. Data warehousing populating processes are a very particular type of software used to migrate data from one or more data sources to a specific data schema used to support decision support activities. The quality of such processes should be guarantee. Otherwise, the final system will deal with data inconsistencies and errors, compromising its suitability to support strategic business decisions. To minimize such problems, we propose a pattern-oriented approach to support ETL lifecycle, from conceptual representation to its execution primitives using a specific commercial tool. An ontology-based meta model it was designed and used for describing patterns internal specification and providing the means to support and enable its configuration and instantiation using a domain specific language., info:eu-repo/semantics/publishedVersion