AocML: A Domain-Specific Language for Model-Driven Development of Activity-Oriented Context-Aware Applications

Activity-oriented context-aware (AOCA) applications are representative in pervasive computing. These applications recognize daily-life human activities, perceive the environment status related to the activities, and react to ensure the smooth performance of the activities. Existing research proposed a specific light-weight, incremental method to support the development of such applications; however it is not easy to learn and use. This paper aims to facilitate the development of such applications and improve the productivity of developers. We propose AocML, a textual domain-specific language which provides a high-level abstraction of AOCA applications. Specifically, we first show the software model of AOCA applications and the abstract syntax of AocML. Then, we introduce the concrete syntax of AocML. We also implement the tools for AocML, including the development environment as well as the generation of Java code and ontology specification. Moreover, we use a case study and evaluation to demonstrate the advantages of AocML.     

Inferring Context-Free Grammars for Domain-Specific Languages

In the area of programming languages, context-free grammars (CFGs) are of special importance since almost all programming languages employ CFG's in their design. Recent approaches to CFG induction are not able to infer context-free grammars for general-purpose programming languages. In this paper it is shown that syntax of a small domain-specific language can be inferred from positive and negative programs provided by domain experts. In our work we are using the genetic programming approach in grammatical inference. Grammar-specific heuristic operators and nonrandom construction of the initial population are proposed to achieve this task. Suitability of the approach is shown by examples where underlying context-free grammars are successfully inferred.     

A Pedagogical Framework for Domain-Specific Languages

A framework for thinking about domain-specific languages (DSLs) divides them into internal DSLs, external DSLs, and language workbenches. In all cases, it's important to have an explicit semantic model so that they form a veneer over an underlying library. DSLs are valuable for increasing programmer productivity and improving communication with domain experts.     

Domain-Specific Modeling Languages to improve framework instantiation

Frameworks are reusable software composed of concrete and abstract classes that implement the functionality of a domain. Applications reuse frameworks to enhance quality and development efficiency. However, frameworks are hard to learn and reuse. Application developers must understand the complex class hierarchy of the framework to instantiate it properly. In this paper, we present an approach to build a Domain-Specific Modeling Language (DSML) of a framework and use it to facilitate framework reuse during application development. The DSML of a framework is built by identifying the features of this framework and the information required to instantiate them. Application generators transform models created with the DSML into application code, hiding framework complexities. In this paper, we illustrate the use of our approach in a framework for the domain of business resource transactions and a experiment that evaluated the efficiency obtained with our approach.     

Model-Driven Development

The model-driven architecture (MDA) paradigm is well-known and widely used in the field of model-based software development. However, there are still some issues that are problematic and that need to be dealt with carefully. In this paper we present a metaphor that explains how MDA grows in complexity as problems faced become more difficult or “wicked”, and how a method designed to be powerful, flexible and MDA-compliant can eventually become, in effect, a “jigsaw puzzle”. This jigsaw puzzle is not merely the result of having a collection of methodological “pieces” with routes across them, but also arises as a result of the criteria underlying the MDA abstraction layers. We compare MDA to other research fields such as human-computer interaction, model management and method engineering, and we use as an example the OO-Method, a software development method based on MDA-compliant model transformations. We focus on a methodological piece that is conceived to allow the specification of interaction requirements by means of interface sketches. These sketches are supported by a task model that serves as a sound basis for formalisation and allows the application of model transformation in order to obtain subsequent models. A case study illustrates the requirements capture method together with the software development process defined by the OO-Method. The whole process presented in the case study represents one of the possible routes that can be followed when developing a software system with the OO-Method.     

Domain-Specific Languages: What, Why, How

Domain-specific languages (DSLs) are being increasingly used as a realistic approach to address a program family. That is, a set of programs that shares enough commonalities to be considered as a whole. These programs may already exist or be expected to be developed. In this situation, in principle, software development can benefit from introducing a DSL in that (1) it offers concise and specific notations to express a member of the program family, and (2) it enables the development of safe code thanks to its restricted semantics and/or requirements for additional information.The Compose group has developed DSLs for various domains such as device drivers, active networking, and process scheduling, and built some experience in designing and implementing DSLs. In this talk we will report on the outcomes of this line of work. In particular, we will attempt to provide a practical definition of a DSL, and give the conditions to make this approach successful. We will discuss actual benefits of the DSL approach. Finally, we will outline a methodology to design and implement a DSL.     

UML-Based Model-Driven Development for HSDPA Design

UML-based model- driven development can reduce the costs of developing, maintaining, and evolving complex software systems. Experiments with a High-Speed Downlink Packet Access design illustrate this approach's effectiveness.     

Design for Proof: An Approach to the Design of Domain-Specific Languages

We propose that the domain of a Domain-Specific Language (DSL) can be characterised by: 1. the class of environments in which systems developed in the language are expected to operate; and 2. the class of properties which such systems are expected to possess. The design of DSLs should therefore include the development of a proof system that eases the task of proving the properties in the class identified for the anticipated operating environments. We develop these ideas in the context of industrial computing systems by presenting a semantics and proof system for a language based on IEC 1131-3, the international standard programming language for programmable controllers. Of particular significance in this example is the use of a diagrammatic representation and the development of a proof system for a class of invariance properties that requires only local knowledge of the structure of diagrams. Received February 1998 / Accepted in revised form October 1998     

Model-Driven Development in the Enterprise

For decades, model-driven development has been the perfect example of software-engineering hype. Just as bees are attracted to honey, we software engineers look for ways of simplifying our work and automating endless change cycles. Today, after many years of experimenting with MDD, mostly in limited-size scientific environments, the three ingredients of methodology, notation, and tools seem to fit and support each other. Round-trip engineering might still be some years from day-to-day practice, but simple forward engineering with MDD is readily available to software practitioners now. And it works. In this issue's column, Axel Uhl, chief development architect in SAP's Office of the CTO, looks into MDD methodologies and tool support. He shares his many practical experiences to help you master the ramp-up for your own enterprise.     

Generating CAM aspect-oriented architectures using Model-Driven Development

Aspect-Oriented Software Development promotes the separation of those concerns that cut across several components and/or are tangled with the base functionality of a component, through all phases of the software lifecycle. The benefit of identifying these crosscutting concerns (aspects) at the architectural level in particular is to improve the architecture design and its subsequent evolution, before moving onto detailed design and implementation. However, software architects are not usually experts on using specific AO architecture notations. Therefore, the aim of this paper is to provide support to define and specify aspect-oriented (AO) architectures using non-AO ones as the source. We will use the Model-Driven Development approach to transform a component-based architecture model into an AO architecture model. The CAM (component and aspect model) model and the DAOP–ADL language are the proposals used for modelling and specifying AO architectures. We will show how we automated part of the process and the tool support.     

Worst Practices for Domain-Specific Modeling

Interest in creating domain-specific modeling (DSM) languages is surging, but little guidance is available on how to do it right. Along with heeding best practices, learning what not to do—including how to handle common pitfalls and recognize troublesome areas—can help first-time developers. The authors have identified several worst practices based on an analysis of 76 DSM cases spanning 15 years, four continents, several tools, around 100 language creators, and projects with from three to more than 300 modelers. They present these worst practices in the order that language developers would encounter them over the life of a project.     

A Domain-Specific Modeling approach for supporting the specification of Visual Instructional Design Languages and the building of dedicated editors

This paper presents, illustrates and discusses theories and practices about the application of a domain-specific modeling (DSM) approach to facilitate the specification of Visual Instructional Design Languages (VIDLs) and the development of dedicated graphical editors. Although this approach still requires software engineering skills, it tackles the need of building VIDLs allowing both visual models for human-interpretation purposes (explicit designs, communication, thinking, etc.) and machine-readable notations for deployment or other instructional design activities. This article proposes a theoretical application and a categorization, based on a domain-oriented separation of concerns of instructional design. It also presents some practical illustrations from experiments of specific DSM tooling. Key lessons learned as well as observed obstacles and challenges to deal with are discussed in order to further develop such an approach.     

Model-Driven Development for scientific computing. An upgrade of the RHEEDGr program

Model-Driven Engineering (MDE) is the software engineering discipline, which considers models as the most important element for software development, and for the maintenance and evolution of software, through model transformation. Model-Driven Architecture (MDA) is the approach for software development under the Model-Driven Engineering framework. This paper surveys the core MDA technology that was used to upgrade of the RHEEDGR program to C++0x language standards.

New version program summary

Program title: RHEEDGR-09Catalogue identifier: ADUY_v3_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADUY_v3_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 21 263No. of bytes in distributed program, including test data, etc.: 1 266 982Distribution format: tar.gzProgramming language: Code Gear C++ BuilderComputer: Intel Core Duo-based PCOperating system: Windows XP, Vista, 7RAM: more than 1 MBClassification: 4.3, 7.2, 6.2, 8, 14Does the new version supersede the previous version?: YesNature of problem: Reflection High-Energy Electron Diffraction (RHEED) is a very useful technique for studying growth and surface analysis of thin epitaxial structures prepared by the Molecular Beam Epitaxy (MBE). The RHEED technique can reveal, almost instantaneously, changes either in the coverage of the sample surface by adsorbates or in the surface structure of a thin film.Solution method: The calculations are based on the use of a dynamical diffraction theory in which the electrons are taken to be diffracted by a potential, which is periodic in the dimension perpendicular to the surface.Reasons for new version: Responding to the user feedback the graphical version of the RHEED program has been upgraded to C++0x language standards. Also, functionality and documentation of the program have been improved.Summary of revisions:

1.

Model-Driven Architecture (MDA) is the approach defined by the Object Management Group (OMG) for software development under the Model-Driven Engineering framework [1]. The MDA approach shifts the focus of software development from writing code to building models. By adapting a model-centric approach, the MDA approach hopes to automate the generation of system implementation artifacts directly from the model. The following three models are the core of the MDA: (i) the Computation Independent Model (CIM), which is focused on basic requirements of the system, (ii) the Platform Independent Model (PIM), which is used by software architects and designers, and is focused on the operational capabilities of a system outside the context of a specific platform, and (iii) the Platform Specific Model (PSM), which is used by software developers and programmers, and includes details relating to the system for a specific platform. Basic requirements for the calculation of the RHEED intensity rocking curves in the one-beam condition have been described in Ref. [2]. Fig. 1 shows the PIM for the present version of the program. Fig. 2 presents the PSM for the program.

2.

The TGraph2D.bpk package has been recompiled to Graph2D0x.bpl and upgraded according to C++0x language standards. Fig. 3 shows the PSM of the Graph2D component, which is manifested by the Graph2D0x.bpl package presently. This diagram is a graphic presentation of the static view, which shows a collection of declarative model elements and their relationships. Installation instructions of the Graph2D0x package can be found in the new distribution.

3.

The program requires the user to provide the appropriate parameters for the crystal structure under investigation. These parameters are loaded from the parameters.ini file at run-time. Instructions for the preparation of the .ini files can be found in the new distribution.

4.

The program enables carrying out one-dimensional dynamical calculations for the fcc lattice, with a two-atoms basis and fcc lattice, with one atom basis but yet the zeroth Fourier component of the scattering potential in the TRHEED1D::crystPotUg() function can be modified according to users' specific application requirements.

5.

A graphical user interface (GUI) for the program has been reconstructed.

6.

The program has been compiled with English/USA regional and language options.

Unusual features: The program is distributed in the form of main projects RHEEDGr_09.cbproj and Graph2D0x.cbproj with associated files, and should be compiled using Code Gear C++ Builder 2009 compilers.Running time: The typical running time is machine and user-parameters dependent.References:

[1]

OMG, Model Driven Architecture Guide Version 1.0.1, 2003, http://www.omg.org/cgi-bin/doc?omg/03-06-01.

[2]

A. Daniluk, Comput. Phys. Comm. 166 (2005) 123.

     

Continuous Model-Driven Engineering

CMDE has been successfully applied in several industrial projects, including telecommunication services, supply-chain management, bioinformatics, logistics, and healthcare. In all these cases, agility at the customer, user, and application level proved key to aligning and linking business and IT. We now expect an additional boost when integrating this approach into a processor project-management environment that oversees development and evolution. This environment will include deadline management and progress reports, automatically informing all relevant parties when certain actions are required, managing different versions and product lines, and automatically steering the build and quality-management process. Perhaps not surprisingly, the development of this management environment proved to be a prime application of CMDE.     

关于在嵌入式软件开发中应用模型驱动开发技术的探讨

为解决传统嵌入式软件开发中存在的制约嵌入式软件开发效率和质量的问题,提出在嵌入式软件开发中应用模型驱动开发技术,介绍了模型驱动开发技术,分析了模型驱动开发技术的优势,并探讨了在嵌入式软件开发中应用模型驱动骨发技术的前景。     

Overview of Center for Domain-Specific Computing

In this short article, we would like to introduce the Center for Domain-Specific Computing (CDSC) established in 2009, primarily funded by the US National Science Foundation with an award from the 2009 Expeditions in Computing Program. In this project we look beyond parallelization and focus on customization as the next disruptive technology to bring orders-of-magnitude power-performance efficiency improvement for applications in a specific domain.