Search

Domain-specific languages (DSL) are programming or modeling languages devoted to a given application domain. There are many tools used to support the implementation of a DSL, making hard the decision-making process for one or another. In this sense, identifying and mapping their features is relevant for decision-making by academic and industrial initiative on DSL development. Objective: The goal of this work is to identify and map the tools, Language Workbenches (LW), or frameworks that were proposed to develop DSLs discussed and referenced in publications between 2012 and 2019. Method: A Systematic Mapping Study (SMS) of the literature scoping tools for DSL development. Results: We identified 59 tools, including 9 under a commercial license and 41 with non-commercial licenses, and analyzed their features from 230 papers. Conclusion: There is a substantial amount of tools that cover a large number of features. Furthermore, we observed that usually, the developer adopts one type of notation to implement the DSL: textual or graphical. We also discuss research gaps, such as a lack of tools that allow meta-meta model transformations and that support modeling tools interoperability. [ABSTRACT FROM AUTHOR]

Domain-specific languages promise to improve productivity and quality of software development by providing problem-adequate abstractions to developers. Projectional language workbenches, in turn, allow the definition of modular and extensible domain specific languages, generators, and development environments. While recent advances in language engineering have enabled the definition of DSLs and tooling in a modular and cost-effective way, the quality assurance of their implementation is still challenging. In this paper, we discuss our work on testing different aspects of the implementation of domain specific languages and associated tools, and present several approaches to increase the automation of language testing. We illustrate these approaches with the Jetbrains MPS language workbench and our experience with testing mbeddr, a set of domain specific languages and tools on top of C tailored to embedded software development. Based on the experience gained from the mbeddr project, we extract generic lessons for practitioners as well as challenges which need more research. [ABSTRACT FROM AUTHOR]

The purpose of a domain-specific language (DSL) is to enable the application programmer to specify a problem, or an abstract algorithm description, in his/her domain of expertise without being burdened by implementation details. The ideal scenario is that the implementation detail is added in an automatic process of program translation and code generation. The approach of domain-specific program generation has lately received increasing attention in the area of computational science and engineering. In this paper, we introduce the new code generation framework Athariac. Its goal is to support the quick implementation of a language processing and program optimization platform for a given DSL based on stepwise term rewriting. We demonstrate the framework’s use on our DSL ExaSlang for the specification and optimization of multigrid solvers. On this example, we provide evidence of Athariac’s potential for making domain-specific software engineering more productive. [ABSTRACT FROM AUTHOR]

This paper presents an extension of the agent-oriented domain-specific language ALAS to support Distributed Non-Axiomatic Reasoning. ALAS is intended for the development of specific kind of intelligent agents. It is designed to support the Siebog Multi-Agent System (MAS) and implementation of the Siebog intelligent agents. Siebog is a distributed MAS based on the modern web and enterprise standards. Siebog offers support to reasoning based on the Distributed Non-Axiomatic Reasoning System (DNARS). DNARS is a reasoning system based on the Non-Axiomatic Logic (NAL). So far, DNARS-enabled agents could be written only in Java programming language. To solve the problem of interoperability and agent mobility within Siebog platforms, the ALAS language has been developed. The goal of such language is to allow programmers to develop intelligent agents easier by using domain specific constructs. The conversion process of ALAS code to Java code is also described in this paper. [ABSTRACT FROM AUTHOR]

In this paper we present MicroBuilder, the tool used for the specification of a software architecture that follows REST microservice design principles. MicroBuilder comprises MicroDSL and MicroGenerator modules. The MicroDSL module provides the MicroDSL domain-specific language used for the specification of REST microservice software architecture. In this paper we present MicroDSL meta-model, specified in Ecore, together with textual and graphical concrete syntaxes, specified using Xtext and Sirius frameworks respectively. The MicroGenerator module is used to generate executable program code based on MicroDSL specification. In this paper we also present results of the MicroBuilder tool evaluation, alongside the case study which illustrates a usage of MicroBuilder. [ABSTRACT FROM AUTHOR]

Performance optimizations should focus not only on the computations of an application, but also on the internal data layout. A well-known problem is whether a struct of arrays or an array of structs results in a higher performance for a particular application. Even though the switch from the one to the other is fairly simple to implement, testing both transformations can become laborious and error-prone. Additionally, there are more complex data layout transformations, such as a color splitting for multi-color kernels in the domain of stencil codes, that are manually difficult. As a remedy, we propose new flexible layout transformation statements for our domain-specific language ExaSlang that support arbitrary affine transformations. Since our code generator applies them automatically to the generated code, these statements enable the simple adaptation of the data layout without the need for any other modifications of the application code. This constitutes a big advance in the ease of testing and evaluating different memory layout schemes in order to identify the best. [ABSTRACT FROM AUTHOR]

Pure embedding as an implementation strategy of domain-specific languages (DSLs) benefits from low implementation costs. On the other hand, it introduces undesired syntactic noise that impedes involvement of non-programming domain experts. Due to this, pure embedded DSLs are generally not intended for, nor used by, non-programmers. In this work, we try to challenge this state by experimenting with inexpensive customizations of the host IDE (Integrated Development Environment) to reduce the negative impact of syntactic noise. We present several techniques and recommendations based on standard IDE features (e.g., file templates, code folding, etc.) that aim to reduce syntactic noise and generally improve the user experience with pure embedded DSLs. The techniques are presented using a NetBeans IDE case study. The goal of the proposed techniques is to improve the user experience with pure embedded DSLs with a focus on the involvement of non-programming domain experts (or non-programmers in general). The proposed techniques were evaluated using a controlled experiment. The experiment compared a group using Ruby and non-modified RubyMine IDE versus a group using Java and NetBeans IDE customized to use the proposed techniques. Experiment results indicate that even inexpensive host IDE customizations can significantly alleviate issues caused by the syntactic noise: Java with its inflexible syntax performed better than Ruby with its concise syntax. [ABSTRACT FROM AUTHOR]

Domain-specific accelerators (DSAs), which sacrifice programmability for efficiency, are a reaction to the waning benefits of device scaling. This article demonstrates that there are commonalities between DSAs that can be exploited with programmable mechanisms. The goals are to create a programmable architecture that can match the benefits of a DSA and to create a platform for future accelerator investigations. [ABSTRACT FROM AUTHOR]

We describe NIMBLE, a system for programming statistical algorithms for general model structures within R. NIMBLE is designed to meet three challenges: flexible model specification, a language for programming algorithms that can use different models, and a balance between high-level programmability and execution efficiency. For model specification, NIMBLE extends the BUGS language and creates model objects, which can manipulate variables, calculate log probability values, generate simulations, and query the relationships among variables. For algorithm programming, NIMBLE provides functions that operate with model objects using two stages of evaluation. The first stage allows specialization of a function to a particular model and/or nodes, such as creating a Metropolis-Hastings sampler for a particular block of nodes. The second stage allows repeated execution of computations using the results of the first stage. To achieve efficient second-stage computation, NIMBLE compiles models and functions via C++, using the Eigen library for linear algebra, and provides the user with an interface to compiled objects. The NIMBLE language represents a compilable domain-specific language (DSL) embedded within R. This article provides an overview of the design and rationale for NIMBLE along with illustrative examples including importance sampling, Markov chain Monte Carlo (MCMC) and Monte Carlo expectation maximization (MCEM). Supplementary materials for this article are available online. [ABSTRACT FROM AUTHOR]

Abstract: The common approach enabling a resource constrained device to get connected to the Internet is through programming instructions and transferring it to an embedded device. This procedure involves various tools and cross-compiling of the code depending on the platform architecture. In practical IoT applications, where a huge number of nodes exist, this process becomes almost impossible due to the heterogeneous platforms and protocols involved and the deployment conditions. This paper introduces a flexible and scalable approach that enhances modifiability and programmability through client-server-server-client architecture. It allows changing the behavior of the system after deployment through a lightweight script written with a domain specific language, DoS-IL, and stored in a gateway at the fog layer. An embedded resource browser is used to request and execute the script. The results of analysis for this model and the tools developed along the way are discussed. [ABSTRACT FROM AUTHOR]

Recent advances in tooling and modern programming languages have progressively brought back the practice of developing domain-specific languages as a means to improve software development. Consequently, the problem of making composition between languages easier by emphasizing code reuse and componentized programming is a topic of increasing interest in research. In fact, it is not uncommon for different languages to share common features, and, because in the same project different DSLs may coexist to model concepts from different problem areas, it is interesting to study ways to develop modular, extensible languages. Earlier work has shown that traits can be used to modularize the semantics of a language implementation; a lot of attention is often spent on embedded DSLs; even when external DSLs are discussed, the main focus is on modularizing the semantics. In this paper we will show a complete trait-based approach to modularize not only the semantics but also the syntax of external DSLs, thereby simplifying extension and therefore evolution of a language implementation. We show the benefits of implementing these techniques using the Scala programming language. [ABSTRACT FROM AUTHOR]

Nowadays, concurrent programs are an inevitable part of many software applications. They can increase the computation performance of the applications by parallelizing their computations. One of the approaches to realize the concurrency is using multi thread programming. However, these systems are structurally complex considering the control of the parallelism (such as thread synchronization and resource control) and also considering the interaction between their components. So, the design of these systems can be difficult and their implementation can be error-prone especially when the addressed system is big and complex. On the other hand, a Domain-specific Modeling Language (DSML) is one of the Model Driven Development (MDD) approaches which tackles this problem. Since DSMLs provide a higher abstraction level, they can lead to reduce the complexities of the concurrent programs. With increasing the abstraction level and generating the artifacts automatically, the performance of developing the software (both in design and implementation phases) is increased, and the efficiency is raised by reducing the probability of occurring errors. Thus, in this paper, a DSML is proposed for concurrent programs, called DSML4CP, to work in a higher level of abstraction than code level. To this end, the concepts of concurrent programs and their relationships are presented in a metamodel. The proposed metamodel provides a context for defining abstract syntax, and concrete syntax of the DSML4CP. This new language is supported by a graphical modeling tool which can visualize different instance models for domain problems. In order to clarify the expressions of the language; the static semantic controls are realized in the form of constraints. Finally, the architectural code generation is fulfilled via model transformation rules using the templates of the concurrent programs. To increase level of the DSML׳s leverage and to demonstrate the general support of concurrent programming by the DSML, the transformation mechanism of the tool supports two well-known and highly used programming languages for code generation; Java and C#. The performed experiments on two case studies indicate a high performance for proposed language. In this regard, the results show automatic generation of 79% of the final code and 86% of the functions/modules on average. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

The prevalent application of domain-specific modeling languages (DSMLs) requires developers to initially specify the require- ments for a software product as a domain-specific model then transform that model to a high-level language for subsequent ex- ecution. An alternative is to realize behavior directly by executing the models using a specialized interpreter. One category of interpreted domain-specific modeling languages (DSMLs) derives behavior from changes to models at runtime. These are termed interpreted DSMLs or simply i-DSMLs . Existing interpreters for i-DSMLs exhibit tight coupling between the implicit model of execution (MoE) and the semantics of the domain. The interweaving of these two concerns compounds the challenge of developing interpreters for new i-DSMLs without a significant investment in resources. This paper introduces a generalized approach to developing i-DSML interpreters by utilizing a generic framework that is loosely coupled to the domain-specific knowledge as swappable framework extensions. We present a prototype as validation of our ap- proach implemented using a metamodel based architecture to instantiate the interpreter for two distinct cyber-physical domains. [ABSTRACT FROM AUTHOR]

Model-based software development tools should provide user-friendly navigation services to allow users browsing (show/hide and zoom in/zoom out) various model details in diagrams. This functionality is crucial in development of large-scale models. In this paper, we present an approach for formal definition of navigation services based on transformations. We introduce view-to-view transformations applying ATL, and present formal definition of navigation service. We also present a prototype implementing the approach. The prototype adds facilities of navigation servicers design to GMF and uses KIELLER toolset for layout of transformation results. A graphical editor for UML class diagrams with 12 navigation services, which have been specified using the approach, is presented. [ABSTRACT FROM AUTHOR]

SUMMARY Domain-specific languages (DSLs) are well-recognized to ease programming and improve robustness for a specific domain, by providing high-level domain-specific notations and checks of domain-specific properties. The compiler of a DSL, however, is often difficult to develop and maintain, because of the need to define a specific treatment for a large and potentially increasing number of language constructs. To address this issue, we propose an approach for specifying a DSL compiler using control-flow sensitive concrete-syntax based matching rules. These rules either collect information about the source code to carry out checks or perform transformations to carry out compilation. Because rules only mention the relevant constructs, using their concrete syntax, and hide the complexity of control-flow graph traversal, it is easy to understand the purpose of each rule. Furthermore, new compilation steps can be added using only a small number of lines of code. We explore this approach in the context of the z2z DSL for network gateway development and show that it is beneficial to implement the core of its compiler in this manner.Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Deliberate practice is important in many areas of learning, including that of learning to program computers. However, beliefs about the nature of personal traits, known as mindsets, can have a profound impact on such practice. Previous research has shown that those with a fixed mindset believe their traits cannot change; they tend to reduce their level of practice when they encounter difficulty. In contrast, those with the growth mindset believe their traits are flexible; they tend to maintain regular practice despite the level of difficulty. However, focusing on mindset as a single construct focused on intelligence may not be appropriate in the field of computer programming. Exploring this notion, a self-belief survey was distributed to undergraduate software engineering students. It revealed that beliefs about intelligence and programming aptitude formed two distinct constructs. Furthermore, the mindset for programming aptitude had greater utility in predicting software development practice, and a follow-up survey showed that it became more fixed throughout instruction. Thus, educators should consider the role of programming-specific beliefs in the design and evaluation of introductory courses in software engineering. In particular, they need to situate and contextualize the growth messages that motivate students who experience early setbacks. [ABSTRACT FROM AUTHOR]

Abstract: Dynamic programming algorithms are traditionally expressed by a set of matrix recurrences—a low level of abstraction, which renders the design of novel dynamic programming algorithms difficult and makes debugging cumbersome. Bellman's GAP is a declarative, domain-specific language, which supports dynamic programming over sequence data. It implements the algebraic style of dynamic programming and allows one to specify algorithms by combining so-called yield grammars with evaluation algebras. Products on algebras allow to create novel types of analyses from already given ones, without modifying tested components. Bellman's GAP extends the previous concepts of algebraic dynamic programming in several respects, such as an “interleaved” product operation and the analysis of multi-track input. Extensive analysis of the yield grammar and the evaluation algebras is required for generating efficient imperative code from the algebraic specification. This article gives an overview of the analyses required and presents several of them in detail. Measurements with “real-world” applications demonstrate the quality of the code produced. [Copyright &y& Elsevier]

Despite the common claim by mashup platforms that they enable end-users to develop their own software, in practice end-users still don't develop their own mashups, as the highly technical or inexistent user bases of today's mashup platforms testify. The key shortcoming of current platforms is their general-purpose nature, that privileges expressive power over intuitiveness. In our prior work, we have demonstrated that a domainspecific mashup approach, which privileges intuitiveness over expressive power, has much more potential to enable end-user development (EUD). The problem is that developing mashup platforms--domain-specific or not--is complex and time consuming. In addition, domain-specific mashup platforms by their very nature target only a small user basis, that is, the experts of the target domain, which makes their development not sustainable if it is not adequately supported and automated. With this article, we aim to make the development of custom, domain-specific mashup platforms costeffective. We describe a mashup tool development kit (MDK) that is able to automatically generate a mashup platform (comprising custom mashup and component description languages and design-time and runtime environments) from a conceptual design and to provision it as a service. We equip the kit with a dedicated development methodology and demonstrate the applicability and viability of the approach with the help of two case studies. [ABSTRACT FROM AUTHOR]

A considerable portion of software systems today are adopted in the embedded control domain. Embedded control software deals with controlling a physical system, and as such models of physical characteristics become part of the embedded control software. In current practices, usually general-purpose languages (GPL), such as C/C++ are used for embedded systems development. Although a GPL is suitable for expressing general-purpose computation, it falls short in expressing the models of physical characteristics as desired. This reduces not only the readability of the code but also hampers reuse due to the lack of dedicated abstractions and composition operators. Moreover, domain-specific static and dynamic checks may not be applied effectively. There exist domain-specific modeling languages (DSML) and tools to specify models of physical characteristics. Although they are commonly used for simulation and documentation of physical systems, they are often not used to implement embedded control software. This is due to the fact that these DSMLs are not suitable to express the general-purpose computation and they cannot be easily composed with other software modules that are implemented in GPL. This paper presents a novel approach to combine a DSML to model physical characteristics and a GPL to implement general-purpose computation. The composition filters model is used to compose models specified in the DSML with modules specified in the GPL at the abstraction level of both languages. As such, this approach combines the benefits of using a DSML to model physical characteristics with the freedom of a GPL to implement general-purpose computation. The approach is illustrated using two industrial case studies from the printing systems domain. [ABSTRACT FROM AUTHOR]

The main reason for the invention of computer programming languages is for these languages to express a command-to-control machine behavior. Some of these programming languages have specific advantages that are used in specific environments such as structured query language (SQL), hypertext markup language (HTML), and spreadsheet. The common definitions of these languages are domain-specific languages (DSLs). Although DSLs are the best way to deal with specific systems, it is hard to use with other environments or platforms. Groovy is a dynamic programming language that runs on the Java virtual machine. Groovy has some features that allow programmers to manage DSLs within its unique style. Groovy has some disadvantages because it does not support all Java features and syntax while also producing unnecessary byte code during compilation. This paper proposes an extended-architecture technique to implement a computer programming language and compiler through extending Java with Groovy language. The extensible language is called 'JGroovy'. And JGroovy is supported both by Java and Groovy language. We implement the compiler for JGroovy and call it the 'JGroovy compiler' (JGC). By its extended architecture, JGC is more compatible for Java source code than Javac can claim to be. And it also produces a better and more compact byte code than the Groovy compiler, with an approximate improvement of 8-12%. © 2013 Institute of Electrical Engineers of Japan. Published by John Wiley & Sons, Inc. [ABSTRACT FROM AUTHOR]

Historically, hardware acceleration technologies have either been application-specific, therefore lacking in flexibility, or fully programmable, thereby suffering from notable inefficiencies on an application-by-application basis. To address the growing need for domain-specific acceleration technologies, this paper describes a design methodology (i) to automatically generate a domain-specific coarse-grained array from a set of representative applications and (ii) to introduce limited forms of architectural generality to increase the likelihood that additional applications can be successfully mapped onto it. In particular, coarse-grained arrays generated using our approach are intended to be integrated into customizable processors that use application-specific instruction set extensions to accelerate performance and reduce energy; rather than implementing these extensions using application-specific integrated circuit (ASIC) logic, which lacks flexibility, they can be synthesized onto our reconfigurable array instead, allowing the processor to be used for a variety of applications in related domains. Results show that our array is around 2\times slower and 15\times larger than an ultimately efficient ASIC implementation, and thus far more efficient than field-programmable gate arrays (FPGAs), which are known to be 3–4\times slower and 20–40\times larger. Additionally, we estimate that our array is usually around 2\times larger and 2\times slower than an accelerator synthesized using traditional datapath merging, which has, if any, very limited flexibility beyond the design set of DFGs. [ABSTRACT FROM PUBLISHER]

The emergence of yet more cloud offerings from a multitude of service providers calls for a meta cloud to smoothen the edges of the jagged cloud landscape. This meta cloud could solve the vendor lock-in problems that current public and hybrid cloud users face. [ABSTRACT FROM PUBLISHER]

Software Product Line Engineering (SPLE) is a prominent paradigm for the assembly of a family of products using product line core assets. The modeling of software assets that together form the actual products is critical for achieving the strategic benefits of Software Product Lines (SPLs). We propose a feature-based approach to software asset modeling based on abstractions provided by Domain-Specific Kits (DSKs). This approach involves a software Asset Metamodel (AMM) used to derive Asset Modeling Languages (AMLs) that define reusable software assets in domain-specific terms. The approach also prescribes a roadmap for modeling these software assets in conjunction with the product line reference architecture. Asset capabilities can be modeled using feature diagrams as the external views of the software assets. Internal views can be expressed in terms of Domain-Specific Artifacts (DSAs) with Variability Points (VPs), where the domain-specific artifacts are created using Domain-Specific Kits. This approach produces loosely coupled and highly cohesive software assets that are reusable for multiple product lines. The approach is validated by assessing software asset reuse in two different product lines in the finance domain. We also evaluated the productivity gains in large-scale complex projects, and found that the approach yielded a significant reduction in the total project effort. [ABSTRACT FROM AUTHOR]

Despite much progress, developing a pervasive computing application remains a challenge because of a lack of conceptual frameworks and supporting tools. This challenge involves coping with heterogeneous devices, overcoming the intricacies of distributed systems technologies, working out an architecture for the application, encoding it in a program, writing specific code to test the application, and finally deploying it. This paper presents a design language and a tool suite covering the development life-cycle of a pervasive computing application. The design language allows us to define a taxonomy of area-specific building-blocks, abstracting over their heterogeneity. This language also includes a layer to define the architecture of an application, following an architectural pattern commonly used in the pervasive computing domain. Our underlying methodology assigns roles to the stakeholders, providing separation of concerns. Our tool suite includes a compiler that takes design artifacts written in our language as input and generates a programming framework that supports the subsequent development stages, namely, implementation, testing, and deployment. Our methodology has been applied on a wide spectrum of areas. Based on these experiments, we assess our approach through three criteria: expressiveness, usability, and productivity. [ABSTRACT FROM AUTHOR]

MapReduce algorithms can be difficult to write and test due to the accidental complexities involved with existing MapReduce implementations. Furthermore, the configuration details involved in running MapReduce algorithms within a cloud present a set of new challenges. Our research reveals that many details of cloud configuration can be hidden from programmers in an automated and transparent manner. Using concepts from software engineering, we have increased the ease of use for implementing MapReduce algorithms by creating a lightweight domain-specific language (DSL). Additionally, we created a plug-in for the Eclipse integrated development environment (IDE) based on this DSL to automate and hide many cloud configuration details. The goal of the combination of our IDE and DSL is to improve the efficiency and effectiveness for programmers in developing MapReduce algorithms for cloud computing. This paper describes the existing challenges of creating MapReduce algorithms and how our approach minimizes these challenges. MapRedoop is a framework that can be used to transform a program written in a DSL to a MapReduce implementation, which can be deployed and executed in a cloud platform such as Eucalyptus or Amazon's Elastic Compute Cloud (EC2). Assorted examples selected from various domains have been rewritten in the MapRedoop framework to demonstrate its expressiveness and usefulness. Our performance analysis reveals that the advantages gained using our approach can be attained with comparable execution times to the methodologies currently in practice. [ABSTRACT FROM AUTHOR]

Efficient programming methods using metadata will save time, money, and facilitate communication across the study team. The information stored in the metadata files will be used as input into either a SAS® code generator or SAS macros to generate the required outputs. This programming style has been used for generating edit checks, data dumps, patient profiles, data listings, tables, and graphs both successfully and efficiently. [ABSTRACT FROM AUTHOR]

Mnemonics is a Scala library for generating method bodies in JVM bytecode at run time. Mnemonics supports a large subset of the JVM instructions, for which the static typing of the generator guarantees the well-formedness of the generated bytecode. The library exploits a number of advanced features of Scala's type system (type inference with bounded polymorphism, implicit parameters, and reflection) to guarantee that the compiler only accepts legal combinations of instructions at compile time. Additional instructions are supported at the price of a check at run time of the generator. In either case, bytecode verification of generated code is guaranteed to succeed. [ABSTRACT FROM AUTHOR]

The article presents information on domain-specific languages (DSL) used in describing, managing and validating software architecture. The author says that software architecture is dependent on programming languages and the approach centers around building a DSL to help implement it consistently. He mentions that once the team is familiar with the advantages of today's tools, this approach can be considered more feasible than one had thought.

The article explores how software product line (SPL) techniques could improve the reusability of domain-specific languages (DSLs), DSL compositions and supporting tools. It is said that DSLs have helped software developers handle complex software systems throughout their lifecycle since DSLs can be designed to capture domain-level information. However, the specificity of the functions of DSLs have made it hard to reuse, say the authors. Information on the four DSLs, which include the Platform-Independent Component Modeling Language (PICML) and the Scatter software component deployment application, is presented.

The article provides information on ModelTalk, a model-driven authoring and execution software development framework. According to the authors, software development problems arose from the need for a complex business applications that are tailored for each customer and meet extrafunctional requirements. It is said that model-driven development (MDD) is usually used in developing software product line because domain-specific languages (DSLs) offer variability in the management of MDD while supporting a producer-consumer development process. There are two elements in a ModelTalk system implementation, one of which is declarative DSL code.

The article discusses how model-driven engineering (MDE) helped improve the development of domain-specific language (DSL)-based home automation systems. MDE eliminates the use of source code since it uses models to create software and reduces the costs associated with the development of DSLs. Home automation, which is developed through MDE, is reactive system management tool that deals with home security, energy, communications and comfort. However, home automation systems do not have specific languages that allow it to capture requirements. Information on Habitation, a home automation system design methodology that combines MDE and DSL.

The article offers information on domain-specific languages and modeling (DSL&M) approach. According to the author, domain-specific tools are successful in their respective niches because they streamline development. Due to technological innovations, the newer versions of domain-specific languages (DSLs) are easier to define, which in turn increases abstraction and makes development faster. There are several factors that should be considered before using a DSL&M approach in a problem, among them are the definition of the domain and the elements of the domain.

An object-oriented framework is proposed for constructing a virtual machine (VM) to be used in the context of incrementally and iteratively developing a domain-specific language (DSL). The framework is written in C#. It includes abstract instruction and environment classes. By extending these, a concrete layer of classes is obtained whose instances define the semantics of a set of instructions, as well as one or more execution environment instances that can be manipulated by the instructions. The framework provides a generic mechanism for reading a set of instructions, executing them sequentially by default but branching if necessary, storing or retrieving internal variables, and accessing and manipulating the environment as per the instructions. In general, each instruction can execute an arbitrary C# method as specified by the developer. The syntactic form of instructions is limited to five possibilities. Using the framework, a range of VMs can be generated, each tailored to support a developer-designed target-level DSL. Since each such language is built in terms of these five instruction formats, these target-level languages share a common syntactic structure. The result is a platform to support an incremental iterative language design and implementation approach that involves the following three phases: determine a set of target-level instructions with semantics appropriate to the specific domain; determine source-level language instructions whose syntax appeals to the domain specialist and provide a simple compiler to map the source to target instructions. The first two phases are relatively disjoint and importantly separate syntax concerns from semantics concerns. The final phase is quite straightforward. Comparative performance results support the use of the framework as an alternative to using an interpreter or hardcoded VM for DSL development. [ABSTRACT FROM AUTHOR]

A macro that can take more or fewer arguments when it is called than formally declared is often referred to as a variable argument (or varargs) macro. The SAS® macro facility provides a basic mechanism for constructing a varargs macro. When properly developed, a single varargs macro can be used to solve arrays of problems of the same form all together in an orderly and uniform way, which can be especially valuable to the development of standard macros used in pharmaceutical programming. This article first describes the way to define a typical varargs macro using the option PBUFF in the %Macro statement, as well as two simulated methods. It then explores common calling conventions for varargs macros and various approaches to implementing varargs macros based on how individual arguments can be retrieved from varargs lists passed at runtime. In addition, the advantages and disadvantages of using varargs macros are briefly discussed, and the techniques are illustrated with various examples. [ABSTRACT FROM AUTHOR]

AbstractThe HM(X) system is a generalization of the Hindley/Milner system parameterized in the constraint domain X. Type inference is performed by generating constraints out of the program text, which are then solved by the domain-specific constraint solver X. The solver has to be invoked at the latest when type inference reaches a let node so that we can build a polymorphic type. A typical example of such an inference approach is Milner's algorithm W. We formalize an inference approach where the HM(X) type inference problem is first mapped to a CLP(X) program. The actual type inference is achieved by executing the CLP(X) program. Such an inference approach supports the uniform construction of type inference algorithms and has important practical consequences when it comes to reporting type errors. The CLP(X) style inference system, where X is defined by Constraint Handling Rules, is implemented as part of the Chameleon system. [ABSTRACT FROM AUTHOR]