Search

Large Language Models (LLMs) have the potential to catalyze a paradigm shift in end-user robot programming---moving from the conventional process of user specifying programming logic to an iterative, collaborative process in which the user specifies desired program outcomes while LLM produces detailed specifications. We introduce a novel integrated development system, Alchemist, that leverages LLMs to empower end-users in creating, testing, and running robot programs using natural language inputs, aiming to reduce the required knowledge for developing robot applications. We present a detailed examination of our system design and provide an exploratory study involving true end-users to assess capabilities, usability, and limitations of our system. Through the design, development, and evaluation of our system, we derive a set of lessons learned from the use of LLMs in robot programming. We discuss how LLMs may be the next frontier for democratizing end-user development of robot applications. [ABSTRACT FROM AUTHOR]

Developing software in a slightly different way can have a dramatic impact on soft error resilience. This observation can be transferred in a process of improving existing code by transformations. These transformations are of systematic nature and can be automated. In this paper, we present a framework for low level embedded software generation - commonly referred to as firmware - and the inclusion of safety measures in the generated code. The generation approach follows a three stage process starting with formalized firmware specification using both platform dependent and independent firmware models. Finally, C-code is generated from the view model in a straight forward way. Safety measures are included either as part of the translation step between the models or as transformations of single models. [ABSTRACT FROM AUTHOR]

The Gamma Statechart Composition Framework is an integrated tool to support the design, verification and validation as well as code generation for component-based reactive systems. The behavior of each component is captured by a statechart, while assembling the system from components is driven by a domain-specific composition language. Gamma automatically synthesizes executable Java code extending the output of existing statechart-based code generators with composition related parts, and it supports formal verification by mapping composite statecharts to a back-end model checker. Execution traces obtained as witnesses during verification are back-annotated as test cases to replay an error trace or to validate external code generators. Tool demonstration video: https://youtu.be/ng7lKd1wlDo [ABSTRACT FROM AUTHOR]

Even though dataflow models are good at exploiting task-level parallelism of an application, it is difficult to exploit the parallelism of loop structures since they are not explicitly specified in existent dataflow models. To overcome this drawback, we propose a novel extension to the SDF model, called SDF/L graph, specifying the loop structures explicitly in a hierarchical fashion. With a given SDF/L graph specification and the mapping and scheduling information, an application can be automatically parallelized on a multicore system. The enhanced expression capability by the proposed extension is verified with two applications, k-means clustering and deep neural network application. [ABSTRACT FROM AUTHOR]

Designing Automotive SoCs requires product specific support of one or more different design targets as different degrees of safety, reliability, very low power, or high current support as well as different design features as multi-core, sensor-on-chip, or system-in-package. Considering that wide design space, it's clear that EDA industry that is focusing on generic applicable tools leaves a wide field for automation unsupported. This paper presents a novel approach to system synthesis named Metasynthesis. It proposes a new highly flexible methodology based on synthesizing system synthesis tools. These synthesized tools finally make the synthesis step from a description above implementation level, e.g. requirements, specification, or a domain specific description to implementation level, e.g. C, SystemVerilog-RTL or schematic. The name "Meta"-Synthesis was chosen in the sense of a synthesis tool "beyond" another synthesis tool or as already said a synthesis tool synthesizing another synthesis tool. The term "Meta" also reflects the underlying metamodeling technique. Even if the approach requires additional effort in building the system synthesis tool, it helps to shorten overall design time, since building the tool is highly automated due to the presented Metasynthesis approach. Also the input views are fast to make since they can be kept simple and compact. The Metasynthesis approach was proven so far in over 90 different automotive SoC and other applications gaining productivity improvements of 95% considering single design steps and gaining up to 70% effort reduction for the complete implementation of automotive SoCs. Some designers report, that they generate up to 80% of the chip's overall RTL code with synthesized tools. [ABSTRACT FROM AUTHOR]

In this paper is presented the process of generating code which has the objective the integration of 8051 microcontrollers as primitive embedded devices to conventional service oriented architectures (SOA). We base our study in CORBA distributed platform. Microcontroller transfers and applies requests/responses between conventional machines and sensors/actuators. Since it is impossible to implement SOA technologies in primitive devices such as 8051 microcontrollers a solution is presented which introduces bind servers to mediate between high level SOA requests to low level intended for microcontroller. We present the automated generation of code for bind server basing on Interface Definition Language (IDL) as input for JacORB -- a Java implementation of CORBA. [ABSTRACT FROM AUTHOR]

Business process automation is very much important for the customer satisfaction and for good productivity. UML Activity diagram is a behavioral diagram which is suitable to model business process. The activity diagram can be enhanced using Object Constraint Language (OCL). This elaboration will help us to include more implementation specific details in the activity diagram. In this paper we present different possibilities to include OCL in the activity diagram and their metamodels. The paper proposes an algorithm to convert the OCL statements to a target code. The OCL enhanced activity diagram can be converted to any target language like Java, C++ etc. In this paper we are converting the system design, represented in activity diagram, to Java code. We also present a prototype of the code generator named ActivityOCLKode and we evaluate the prototype with parameters like complexity, percentage of code generated. [ABSTRACT FROM PUBLISHER]

Service-oriented architectures utilize loosely coupled services to support the constantly changing requirements of software by assembling services into composite applications. However, there is a tremendous amount of intellectual capital invested in legacy C and C++ applications. Reusing these applications will largely save the original investment. Several excellent projects concentrate on conversion of existing C and C++ applications into web services in a C++ runtime environment. However, in some special scenario, it is an alternative that deploys C/C++ web services in a runtime written in another language such as Java. This paper presents an automatic toolkit for exposing existing C/C++ applications as services which can be deployed in runtime environments written in Java programming language. [ABSTRACT FROM PUBLISHER]

An instruction scheduling technique is presented that targets at improving the reliability of a software program given a userprovided tolerable performance overhead. A look-ahead-based heuristic schedules instructions by evaluating the reliability of dependent instructions while reducing the impact of spatial and temporal vulnerabilities of various processor components. Our reliability-driven instruction scheduler (implemented into the GCC compiler) provides on average a 22% reduction of program failures compared to state-of-the-art. [ABSTRACT FROM AUTHOR]

Offset assignment (OA) is a highly effective address code optimization technique for embedded processors with limited memory. Modify registers (MRs) concern the offset difference of address code for offset assignment (OA) problems. Address registers (ARs) concern the assignment of program variables for general offset assignment (GOA) problems. This paper proposes a novel MRs and ARs assignment technique for SOA and GOA problems based on specialized DSPs Address Generation Units (AGU) machines. A technique to reduce the number of distinct offset difference so as to reduce the modify register assignment instructions was proposed for SOA and during GOA such that the cost is further reduced. An adjustable ARs assignment technique was proposed to reduce the GOA cost and the number of distinct offset difference during GOA. Our experiments show the reduction of the number of distinct offset difference during GOA can also help to improve the GOA cost. [ABSTRACT FROM PUBLISHER]

An integration of aspect orientation and model-driven engineering is expected to enhance software development from many perspectives. Different approaches for this integration have already appeared in literature. In general, all such approaches use aspect-oriented model as the primary artifact and apply different techniques to obtain an executable from it. In this study we have provided a survey of existing research in this context by conducting a systematic mapping study. Classification schemes were defined and 38 selected primary studies were classified on the basis of research focus, contribution type and research type. Results show that solutions proposals are in a majority and current research has mainly focused on using model weavers for the integration (81% versus 19% code generation approaches). The majority of contributions are methods. [ABSTRACT FROM PUBLISHER]

Given its intrinsic complexity, it is not efficient to develop software defined radio (SDR) systems following traditional methodologies. A new methodology is necessary, which should allow the description of the applications at higher abstraction levels. This paper describes such a methodology. It includes domain specific modelling languages (DSML) for SDR applications / SDR architectures, and the mechanisms to generate automatically the deployment code. The DSML language is described with precise syntax and semantics to support simulation, synthesis, and formal analysis. The potential of the modelling language is illustrated by designing a cognitive radio application called Welch period gram detector. [ABSTRACT FROM PUBLISHER]

Situational applications are typically short term applications that have to be developed with a limited programming effort by combining third-parties APIs. Recently, public Web sites offer an opportunity in this direction by providing large, ever growing, catalogues of Web APIs. Developers can select and integrate Web APIs to obtain, so called, mashup applications. Two relevant issues in this scenario are the selection of suitable Web APIs and producing programming code to integrate them. In this paper, we discuss how a semantics-enabled Web API registry can allow implementing proactive selection patterns for Web APIs to be integrated in a mashup and automatically generate in a guided way a programming code skeleton for the final application. [ABSTRACT FROM PUBLISHER]

To cope with the complexity of programming GPU accelerators for medical imaging computations, we developed a framework to describe image processing kernels in a domain-specific language, which is embedded into C++. The description uses decoupled access/execute metadata, which allow the programmer to specify both execution constraints and memory access patterns of kernels. A source-to-source compiler translates this high-level description into low-level CUDA and Open CL code with automatic support for boundary handling and filter masks. Taking the annotated metadata and the characteristics of the parallel GPU execution model into account, two-layered parallel implementations - utilizing SPMD and MPMD parallelism - are generated. An abstract hardware model of graphics card architectures allows to model GPUs of multiple vendors like AMD and NVIDIA, and to generate device-specific code for multiple targets. It is shown that the generated code is faster than manual implementations and those relying on hardware support for boundary handling. Implementations from Rapid Mind, a commercial framework for GPU programming, are outperformed and similar results achieved compared to the GPU backend of the widely used image processing library Open CV. [ABSTRACT FROM PUBLISHER]

Performance, code size and power consumption are all primary concern in embedded systems. To this effect, VLIW architecture has proven to be useful for embedded applications with abundant instruction level parallelism. But due to the long instruction bus width it often consumes more power and memory space than necessary. One way to lessen this problem is to adopt a reduced bit-width instruction set architecture (ISA) that has a narrower instruction word length. This facilitates a more efficient hardware implementation in terms of area and power by decreasing bus-bandwidth requirements and the power dissipation associated with instruction fetches. Also earlier studies reported that it helps to reduce the code size considerably. In practice, however, it is impossible to convert a given ISA fully into an equivalent reduced bit-width one because the narrow instruction word, due to bit-width restrictions, can encode only a small subset of normal instructions in the original ISA. Consequently, existing processors provide narrow instructions in very limited cases along with severe restrictions on register accessibility. The objective of this work is to explore the possibility of complete conversion, as a case study, of an existing 32-bit VLIW ISA into a 16-bit one that supports effectively all 32-bit instructions. To this objective, we attempt to circumvent the bit-width restrictions by dynamically extending the effective instruction word length of the converted 16-bit operations. At compile time when a 32-bit operation is converted to a 16-bit word format, we compute how many bits are additionally needed to represent the whole 32-bit operation and store the bits separately in the VLIW code. Then at run time, these bits are retrieved on demand and inserted to a proper 16-bit operation to reconstruct the original 32-bit representation. According to our experiment, the code size becomes significantly smaller after the conversion to 16-bit VLIW code. Also at a slight run time cost, the machine with the 16-bit ISA consumes much less energy than the original machine. [ABSTRACT FROM PUBLISHER]

Information integration, interoperability and adaptation to evolving data are the key components of clinical information system with high potential impact. Most existing systems accomplish integration and interoperability by employing specific data model standards with static mapping rules that makes system inflexible and inextensible. In response to this drawback, we present Health-Connect system that exploits ontology-based model-driven code generation process to provide integration among heterogeneous databases and adaptation capability for frequent requirements changes. Given an ER model over each source-ontology, our tools are able to generate integrated database schema, dynamically create mapping between data sources using UMLS, translates user queries to access the data sources. In addition, this approach provides domain experts a higher level of operation abstraction. Our positive experience shows ontology-based model-driven code generation is a promising approach for clinical information systems that integrate heterogeneous sources and evolve as the application and data sources changes. [ABSTRACT FROM PUBLISHER]

Scientific programmers can speed up function evaluation by precomputing and storing function results in lookup table (LUTs), thereby replacing costly evaluation code with an inexpensive memory access. A code transform that replaces computation with LUT code can improve performance, however, accuracy is reduced because of error inherent in reconstructing values from LUT data. LUT transforms are commonly used to approximate expensive elementary functions. The current practice is for software developers to (1) manually identify expressions that can benefit from a LUT transform, (2) modify the code by hand to implement the LUT transform, and (3) run experiments to determine if the resulting error is within application requirements. This approach reduces productivity, obfuscates code, and limits programmer control over accuracy and performance. We propose source code analysis and program transformation to substantially automate the application of LUT transforms. Our approach uses a novel optimization algorithm that selects Pareto optimal sets of expressions that benefit most from LUT transformation, based on error and performance estimates. We demonstrate our methodology with the Mesa tool, which achieves speedups of 1.4-6.9x on scientific codes while managing introduced error. Our tool makes the programmer more productive and improves the chances of finding an effective solution. [ABSTRACT FROM PUBLISHER]

The Model-Driven Software Development approach is becoming widely used as powerful model-driven tools are becoming available for the developer. Yet, it is not suitable to model, and therefore to generate the code, for all the aspects handled in the development stage. As a result, MDSD is not as widely used as it could. This paper presents a technique that extends the capabilities of Model-Driven Engineering with behavioral aspects, by modeling concerns and using them in code generation. Common concerns can be defined for design patterns, software infrastructures and other common aspects. Independent concerns can be effectively combined when applied to the same model element. Software architects are advised to apply common concerns to their system models and also to create system-specific concerns and apply them at the modeling stage. We name it enriching a model with concerns. With the help of code definition for each concern, our tool automatically generates code for the enriched model. Thus, at the end of the modeling stage the developers will have the structure of the code and all the glue code ready, so they will only have to fill the business logic in the manual implementation methods created for them. They will also maintain the enriched model and not the code they would otherwise write manually. [ABSTRACT FROM PUBLISHER]

In modern processor architectures, the register file (RF) consumes considerable amount of the processor power. It is well known that by allowing software to have explicit fine-grained control over the datapath, the transport-triggered architectures (TTAs) can substantially reduce the RF traffic, thereby minimizing the RF energy. However, it is important to make sure that the gain in RF is not cancelled out by the overhead due to the fine-grained datapath control, in particular, the deterioration of code density in conventional TTAs. In this paper, we analyze the potential of minimizing RF energy in MOVE-Pro, a TTA-based processor framework. We present a flexible compiler backend, which performs energy-aware instruction scheduling to push the limit of RF energy reduction. The experimental results show that with the proposed energy-aware compiler backend, MOVE-Pro is able to significantly reduce RF energy compared to its RISC/VLIW counterparts, by up to 80%. Meanwhile the code density of MOVE-Pro remains at the same level as its RISC/VLIW counterparts, allowing the energy saving in RF to be successfully transferred to total energy saving. [ABSTRACT FROM PUBLISHER]

In software engineering the UML (Object Management Group (OMG), 2004) is nowadays the lingua franca for object-oriented modeling. Development of systems with such modeling language is based principally on models as abstractions of real-world and/or thought concepts where different kinds of models represent different views on a system. During systems development such models are enriched with additional information and are thus transformed from more abstract into more concrete ones. While object oriented models traditionally served as blueprints for manual systems implementation, the model driven architecture initiative of the OMG (OMG, 2003) promotes the usage of models throughout the entire development process. Starting from a so-called Computation Independent Model (CIM), different kinds of transformations lead to Platform Specific Models (PSMs). These PSMs can be used later to generate code for a specific platform. This paper presents a code generation approach by model transformation taking as source models: the Domain Class Diagram (DCD) and Transition's State Diagram (TSD) and instead of generating directly plain text for the chosen platform, an intermediate structural model for the Java platform is generated. Such intermediate model will enable its extensibility with new features. The core idea of this article is code generation by model transformation from transition State diagram for system's complex classes. The generated code contains full details for the class (attributes) and full methods signatures. [ABSTRACT FROM PUBLISHER]

High Performance Computing (HPC) systems are nowadays more and more heterogeneous. Different processor types can be found on a single node including accelerators such as Graphics Processing Units (GPUs). To cope with the challenge of programming such complex systems, this work presents a domain-specific approach to automatically generate code tailored to different processor types. Low-level CUDA and OpenCL is generated from a high-level description of a geometric multigrid algorithm written in a Domain-Specific Language (DSL) instead of writing hand-tuned code for GPU accelerators. By decoupling the algorithm from its schedule, the proposed approach allows to generate efficient stencil codes. Our results show that competitive performance compared to hand-tuned codes can be achieved and that more than 25 frames per second for 16.8 Megapixel images are obtained for full High Dynamic Range (HDR) compression of 2D medical data sets. [ABSTRACT FROM PUBLISHER]

Emerging many-core platforms are very difficult to program in a performance portable manner whilst achieving high efficiency on a diverse range of architectures. We present work in progress on PyOP2, a high-level embedded domain-specific language for mesh-based simulation codes that executes numerical kernels in parallel over unstructured meshes. Just-in-time kernel compilation and parallel scheduling are delayed until runtime, when problem-specific parameters are available. Using generative metaprogramming, performance portability is achieved, while details of the parallel implementation are abstracted from the programmer. PyOP2 kernels for finite element computations can be generated automatically from equations given in the domain-specific Unified Form Language. Interfacing to the multi-phase CFD code Fluidity through a very thin layer on top of PyOP2 yields a general purpose finite element solver with an input notation very close to mathematical formulae. Preliminary performance figures show speedups of up to 3.4x compared to Fluidity's built-in solvers when running in parallel. [ABSTRACT FROM PUBLISHER]

Modern software systems require advanced design support especially capable of mastering rising complexity, as well as of automating as many development tasks as possible. Model-Driven Engineering (MDE) is earning consideration as a solid response to those challenges on account of its support for abstraction and domain specialisation. However, MDE adoption often shatters industrial practice because its novelty opposes the need to preserve vast legacy and to not disband the skills matured in pre-MDE or alternative development solutions. This work presents the CHESS tool environment, a novel approach for cross-domain modelling of industrial complex systems. It leverages on UML profiling and separation of concerns realised through the specification of well-defined design views, each of which addresses a particular aspect of the problem. In this way, extra-functional, functional, and deployment descriptions of the system can be given in a focused manner, avoiding issues pertaining to distinct concerns to interfere with one another. [ABSTRACT FROM PUBLISHER]

Cloud computing is an emerging technology paradigm that revolutionizes the computing landscape by providing on-demand delivery of software, platform, and infrastructure over the Internet. Yet, architecting, deploying, and configuring enterprise applications to run well on modern clouds remains a challenge due to associated complexities and non-trivial implications. The natural and presumably unbiased approach to these questions is thorough testing before moving applications to production settings. However, thorough testing of enterprise applications on modern clouds is cumbersome and error-prone due to a large number of relevant scenarios and difficulties in testing process. We address some of these challenges through Expertus---a flexible code generation framework for automated performance testing of distributed applications in Infrastructure as a Service (IaaS) clouds. Expertus uses a multi-pass compiler approach and leverages template-driven code generation to modularly incorporate different software applications on IaaS clouds. Expertus automatically handles complex configuration dependencies of software applications and significantly reduces human errors associated with manual approaches for software configuration and testing. To date, Expertus has been used to study three distributed applications on five IaaS clouds with over 10,000 different hardware, software, and virtualization configurations. The flexibility and extensibility of Expertus and our own experience on using it shows that new clouds, applications, and software packages can easily be incorporated. [ABSTRACT FROM PUBLISHER]

Modern avionics architecture is evolving from traditional federated architecture to Integrated Modular Avionics (IMA) architecture. ARINC653 standard, which is employed in the avionics industry, supports partitioning core concept in IMA. Furthermore, avionic software has very high safety and reliability requirements in safety- critical domains. Therefore, how to develop high-integrity avionics software constructed on ARINC653 architecture becomes a very significant problem nowadays. In this paper we propose an automatic RT-Java code generation approach based on the AADL model for ARINC653 (AADL653) to enable the development of RT-Java ARINC653-based avionics software more productive and trustworthy. Our main contribution in this paper includes: (1) a mapping from the AADL653 model to a high-integrity RT-Java programming model for ARINC653 (RT-Java653); (2) an ARINC653-compliant RT-Java code generation algorithm suitable for complex multi-task collaboration interaction situation. Accordingly, we implement this RT-Java class library and corresponding code generator. Moreover, a simplified multi-task flight application as a case study is given to illustrate our approach and the preliminary experiment results show the validity of our approach. [ABSTRACT FROM PUBLISHER]

Framework-based1 applications are quite popularly used in current commercial applications. Framework-based applications are often controlled by XML configuration files. However, most of these frameworks are complex or not well documented, which poses a great challenge for programmers to correctly utilize them. To overcome these difficulties, we propose a new method to recommend XML configuration snippets automatically through mining tree patterns from the application repository with the aim of assisting the programmer to generate proper XML configurations during the product phase. This method is further realized into a new tool XMLSnippet. In this paper, we will systematically present the core techniques of the proposed method, including closed frequent tree pattern mining, prefix tree based indexing and three types of queries (type query, structural query and context query) for online coding assistance. Experimental results show that these techniques are efficient for recommending reusable XML configuration snippets and consequently improve the productivity of programmers effectively with the assistance of the tool when they program with XML-based frameworks. [ABSTRACT FROM PUBLISHER]

There is no discussion on how collaborative tools can enhance the way we perform our everyday tasks. By interacting with each other we can find out the answers to our questions and improve the quality of our decisions. Moreover, the tools available make it very easy to spread our issues and gather results and feedback online within a very short response time. When it comes to traditional information systems the wisdom of the crowds' principle is neglected. The vast majority of information systems deployed provides no collaborative tool aimed at supporting users to perform their tasks. The community of users of any information system is a powerful resource of tacit knowledge that must be exploited. The MDArte framework has been used to develop information systems through the Model Driven Architecture approach, automating the generation from models reaching around 80% of the application code. This paper presents the Collaborative MDArte initiative which goes further in the automatic generation embedding collaborative tools into generated information systems with no additional efforts. [ABSTRACT FROM PUBLISHER]

Many-core Graphics Processing Units (GPU) provide a high-performance parallel hardware platform on the desktop at an incredibly low cost. However, the widespread use of this computational capacity is hindered by the fact that programming GPUs is difficult. The state-of-the-art is to develop code utilizing the NVIDIA Compute Unified Device Architecture (CUDA). However, effective use of CUDA requires developers highly skilled in both low-level systems programming and parallel processing. Recognizing this roadblock to widespread adaption of General-Purpose Computing on GPUs (GPGPU), the NVIDIA Performance Primitives (NPP) library was released recently. While greatly easing the burden, utilizing NPP still requires one to learn CUDA. In this paper, we introduce a graphical environment for the design of image processing workflows that automatically generates all the CUDA code including NPP calls necessary to run the application on a GPU. Experimental results show that the generated code is almost as efficient as the equivalent hand written program and 10 times faster than running on the CPU alone in the typical case. [ABSTRACT FROM PUBLISHER]

This paper deals with the problem of automated conversion of formal system specification to the executable implementation that preserves the reconfigurability of the original model within its runtime. Formal part of the work is based on Coloured Petri Nets formalism extended with the nets-within-nets structural paradigm introduced by Valk. This paradigm reduces the partitioning problem using multiple levels of abstraction within modeling. Described solution aims to produce the distributed control system using five levels of abstraction and a set of translation rules that produces the target prototype. The main contribution of the paper is the introduction of mapping rules that are used for prototype generation and the concept of distributed virtual machine that interprets Petri Nets specifications and supports the reconfigurability of the system. [ABSTRACT FROM PUBLISHER]

Code generators are important tools in software development, to automate repetitive coding tasks, facilitate portability, abstract implementation details, and reduce development costs. However, as the complexity of code generators grow, they tend to be harder to maintain, especially when there is a large amount of templates involved. This paper proposes an approach for code generation based on regular expression substitution. Instead of using templates for code generation, this approach transforms existing source code, using regular expression substitution, to implement the required functionality. We are currently applying this technique to strengthen the code generation framework of Heinsohn Business Technology, as part of the “Lion” project co-financed by Colciencias. Our experience shows that, although this approach has a steeper learning curve, it facilitates capitalization of the experience of software development organizations, selecting successfully modules that are taken as a reference source for code generation in future projects. [ABSTRACT FROM PUBLISHER]

This paper proposes a system of automatic code generation for MASINA (Multiagent Systems in Automation). MASINA is a methodology for specifying Multi-agent systems. The code generator takes MASINA models as input, and from them generates code for each one of the agents of the Multiagent System under construction. The code generation system SISGECOMA, as we call it, is composed of several agents: one that is interface with the user and captures all the information provided by him through MASINA models, another agent performs the verification and validation of the information, finally, another agent generates the Multiagents System [ABSTRACT FROM PUBLISHER]

In recent years, Model Driven Engineering (MDE) approaches have been proposed and used to develop and evolve WAs. However, the definition of appropriate MDE approaches for the development of flexible process-centric WAs is still limited. In particular, (flexible) workflow models have never been integrated with the models (e.g., presentation, information models) used in MDE approaches to develop this type of applications. In this paper, we propose an MDE approach for the development and the evolution of flexible process-centric WAs that integrates three MDE metamodels used to represent the main components of a WA with the metamodel of Declare. A case study, carried out to validate the feasibility, correctness and effectiveness of the proposed approach is presented and discussed. [ABSTRACT FROM PUBLISHER]

The primary goal of this work is to provide an easy and systematic way of developing safe soft real-time systems. To achieve this goal, we propose a method of generating real-time programs from formally verified models written as systems of timed automata. The models are verified using UPPAAL model checker prior to be processed by our code generators. A characteristic of our code generator is that the generated code runs in a non-real-time environment, i.e., a runtime environment without inherent real-time schedulers. To realize this, the code generator weaves timing checking code fragments within the generated programs. The generated code explicitly checks the real-time clock of its runtime to obey the timing constraints specified in the model. In this paper, we describe how to generate Java/C programs from UPPAAL timed automata and show the benefits of our method using a robot controller case study. [ABSTRACT FROM PUBLISHER]

It is a wonderful idea to directly execute the system designs. In this paper we are introducing a method to convert the behavioral models to the implementation code. UML is used for modeling and Java is used as the target language. This paper describes how a system design depicted using activity, sequence and statemachine diagrams can be converted to its implementation code. Activity diagram helps to make the outline of the source program, and the sequence and state machine diagrams contribute to the expansion of the source code. We are using an MDA approach where the system design is done in Platform Independent Model (PIM), then converted to Platform Specific Model (PSM) and finally to implementation code. One tool is implemented based on our method and it is evaluated against some other existing tools. [ABSTRACT FROM PUBLISHER]

The development of complex systems requires tool support for the different phases of the system life cycle. To allow for an efficient development process, the involved tools need to be integrated, e.g. by exchanging tool data or providing trace ability between the data. Despite the availability of tool integration platforms and frameworks, it is labor-intensive and costly to build tool integration solutions. Industrial tool integration initiatives such as OSLC (Open Services for Lifecycle Collaboration) demand complex configurations and the adherence to integration standards. This further complicates building an integration solution. We propose an approach that uses formalized specifications to systematize tool integration and specialized code generators to automate the process of building tool adapters. We evaluate our approach with the implementation of a code generator that creates service-oriented tool adapters conforming to the OSLC industry initiative. [ABSTRACT FROM PUBLISHER]

An efficient memory bandwidth utilization for GPU accelerators is crucial for memory bound applications. In medical imaging, the performance of many kernels is limited by the available memory bandwidth since only a few operations are performed per pixel. For such kernels only a fraction of the compute power provided by GPU accelerators can be exploited and performance is predetermined by memory bandwidth. As a remedy, this paper investigates the optimal utilization of available memory bandwidth by means of increasing in-flight memory transactions. Instead of doing this manually for different GPU accelerators, the required CUDA and OpenCL code is automatically generated from descriptions in a Domain-Specific Language (DSL) for the considered application domain. Moreover, the DSL is extended to also support global reduction operators. We show that the generated target-specific code improves bandwidth utilization for memory-bound kernels significantly. Moreover, competitive performance compared to the GPU back end of the widely used image processing library OpenCV can be achieved. [ABSTRACT FROM PUBLISHER]

Framework as a term is very frequently used in software engineering, especially in relation to object-oriented software design and implementation. In general, a framework could be defined as an application generator for one particular domain, or more to the point, it represents a skeleton of an application, that includes the complete code for the basic functions of a system, which can be conformed to the needs of one specific application. In this paper, the definitions and properties of frameworks development process are presented. The second part of the paper will present guidelines for design and implementation of framework for developing desktop applications based on relationship meta-data. The framework should, on the basis of an arbitrary problem domain represented by a meta model, generate application skeleton using three-tier architecture and then implement basic CRUD database operations for the defined problem domain. Finally, conclusion summarizes all done and notes guidelines for further improvements of the implemented framework. [ABSTRACT FROM PUBLISHER]

We describe the Marama suite of meta-tools. This Eclipse-based toolset permits rapid specification of notational elements, meta-models, view editors and view-model mappings. It has a novel set of behavioural specification tools for both visual and model level behaviours. An integrated mapping tool provides model transformation and code generation support. The toolset has been applied to several significant application development tasks and has undergone a variety of evaluations. [ABSTRACT FROM AUTHOR]

We describe the Marama suite of meta-tools. This Eclipse-based toolset permits rapid specification of notational elements, metamodels, view editors and view-model mappings. It has a novel set of behavioural specification tools for both visual and model level behaviours. An integrated mapping tool provides model transformation and code generation support. The toolset has been applied to several significant application development tasks and has undergone a variety of evaluations. [ABSTRACT FROM AUTHOR]

Computer assisted instruction (CAI) is an interactive instructional technique that can be used to assist the learning process. CAI method is a combination of hardware and software capabilities. CAI method allows the learning process between teachers and students become more interactive, interesting, effective, and efficient. One of the software that can be used to develop computer-assisted instruction is flash. In this study we tried to develop computer-assisted instruction using flash for a compiler model, which is making the simulation of stack during code generation of compilation. From the experiments have been made, we success developed a computer assisted instruction that can be used easily, provide more effective and efficient than manual methods of teaching. This is evident from the results of evaluations that have been made. [ABSTRACT FROM PUBLISHER]

Framework-based applications controlled by XML configuration files are quite popularly used in current commercial applications. However, most of these frameworks are complex or not well documented, which poses a great challenge for programmers to correctly utilize them. To overcome these difficulties, we propose a new tool to recommend XML configuration snippets automatically through mining tree patterns and pattern associations from the application repository with the aim of assisting the programmer to generate proper XML configurations during the production phase. In this demo, we showcase this tool by presenting the major techniques behind the tool and the typical usage scenarios of our tool. [ABSTRACT FROM AUTHOR]

Framework-based applications controlled by XML configuration files are quite popularly used in current commercial applications. However, most of these frameworks are complex or not well documented, which poses a great challenge for programmers to correctly utilize them. To overcome these difficulties, we propose a new tool to recommend XML configuration snippets automatically through mining tree patterns and pattern associations from the application repository with the aim of assisting the programmer to generate proper XML configurations during the production phase. In this demo, we showcase this tool by presenting the major techniques behind the tool and the typical usage scenarios of our tool. [ABSTRACT FROM PUBLISHER]

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents SM@RT, a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target system's data type and an API description specifying how to manipulate the data, SM@RT automatically generates the synchronizer to maintain the runtime model for this system. [ABSTRACT FROM AUTHOR]

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents SM@RT, a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target system's data type and an API description specifying how to manipulate the data, SM@RT automatically generates the synchronizer to maintain the runtime model for this system. [ABSTRACT FROM AUTHOR]