Creating, Debugging, and Testing Mobile Applications with the IPAC Application Creation Environment

2012 ◽  
pp. 341-364
Author(s):  
Kostas Kolomvatsos ◽  
George Valkanas ◽  
Petros Patelis ◽  
Stathes Hadjiefthymiades
Keyword(s):  
Embedded Systems ◽  
Software Development ◽  
Programming Languages ◽  
Context Aware ◽  
Mobile Nodes ◽  
Description Language ◽  
Domain Specific Languages ◽  
Specific Domain ◽  
Domain Specific ◽  
Important Challenge

An important challenge in software development is to have efficient tools for creating, debugging, and testing software components developed for specific business domains. This is more imperative if it is considered that a large number of users are not familiar with popular programming languages. Hence, Application Creation Environments (ACEs) based on specific Domain-Specific Languages (DSLs) can provide an efficient way for creating applications for a specific domain of interest. The provided ACEs should incorporate all the functionality needed by developers to build, debug, and test applications. In this chapter, the authors present their contribution in this domain based on the experience of the IPAC system. The IPAC system provides a middleware and an ACE for developing and using intelligent, context-aware services in mobile nodes. The chapter fully describes the ACE, which is a key part of the overall architecture. The ACE provides two editors (textual, visual), a wide functionality spectrum, as well as a debugger and an application emulator. The ACE is based on an Application Description Language (ADL) developed for IPAC. The ADL provides elements for the description of an application workflow for embedded systems. Through such functionality, developers are capable of efficiently creating and testing applications that will be deployed on mobile nodes.

Creating, Debugging, and Testing Mobile Applications with the IPAC Application Creation Environment

2014 ◽  
pp. 695-718
Author(s):  
Kostas Kolomvatsos ◽  
George Valkanas ◽  
Petros Patelis ◽  
Stathes Hadjiefthymiades
Keyword(s):  
Embedded Systems ◽  
Software Development ◽  
Programming Languages ◽  
Context Aware ◽  
Mobile Nodes ◽  
Description Language ◽  
Domain Specific Languages ◽  
Specific Domain ◽  
Domain Specific ◽  
Important Challenge

An important challenge in software development is to have efficient tools for creating, debugging, and testing software components developed for specific business domains. This is more imperative if it is considered that a large number of users are not familiar with popular programming languages. Hence, Application Creation Environments (ACEs) based on specific Domain-Specific Languages (DSLs) can provide an efficient way for creating applications for a specific domain of interest. The provided ACEs should incorporate all the functionality needed by developers to build, debug, and test applications. In this chapter, the authors present their contribution in this domain based on the experience of the IPAC system. The IPAC system provides a middleware and an ACE for developing and using intelligent, context-aware services in mobile nodes. The chapter fully describes the ACE, which is a key part of the overall architecture. The ACE provides two editors (textual, visual), a wide functionality spectrum, as well as a debugger and an application emulator. The ACE is based on an Application Description Language (ADL) developed for IPAC. The ADL provides elements for the description of an application workflow for embedded systems. Through such functionality, developers are capable of efficiently creating and testing applications that will be deployed on mobile nodes.

scholarly journals Program comprehension for domain-specific languages

2008 ◽  
Vol 5 (2) ◽  
pp. 1-17 ◽  
Author(s):  
Maria Pereira ◽  
Marjan Mernik ◽  
Cruz da ◽  
Pedro Henriques
Keyword(s):  
Programming Languages ◽  
Program Comprehension ◽  
Software Systems ◽  
Full Understanding ◽  
Domain Specific Languages ◽  
Specific Domain ◽  
Domain Specific ◽  
Abstraction Level ◽  
The Past ◽  
Relate Problem

In the past, we have been looking for program comprehension tools that are able to interconnect operational and behavioral views, aiming at aiding the software analyst to relate problem and program domains in order to reach a full understanding of software systems. In this paper we are concerned with Program Comprehension issues applied to Domain Specific Languages (DSLs). We are now willing to understand how techniques and tools for the comprehension of traditional programming languages fit in the understanding of DSLs. Being the language tailored for the description of problems in a specific domain, we believe that specific visualizations (at a higher abstraction level, closer to the problem level) could and should be defined to enhance the comprehension of the descriptions in that particular domain. .

MDA, Metamodeling and Transformation

2010 ◽  
pp. 34-47
Author(s):  
Liliana María Favre
Keyword(s):  
Programming Languages ◽  
General Purpose ◽  
Modeling Languages ◽  
Domain Specific Languages ◽  
Domain Specific ◽  
Underlying Principle

MDA requires the ability to understand different languages such as general purpose languages, domain specific languages, modeling languages or programming languages. An underlying principle of MDA for integrating semantically in a unified and interoperable way such languages is using metamodeling techniques.

Extensible Languages

2012 ◽  
pp. 1-31
Author(s):  
Didier Verna
Keyword(s):  
Programming Languages ◽  
General Purpose ◽  
Complete Disappearance ◽  
Domain Specific Languages ◽  
Domain Specific ◽  
Extensible Languages

Out of a concern for focus and concision, domain-specific languages (DSLs) are usually very different from general purpose programming languages (GPLs), both at the syntactic and the semantic levels. One approach to DSL implementation is to write a full language infrastructure, including parser, interpreter, or even compiler. Another approach however, is to ground the DSL into an extensible GPL, giving you control over its own syntax and semantics. The DSL may then be designed merely as an extension to the original GPL, and its implementation may boil down to expressing only the differences with it. The task of DSL implementation is hence considerably eased. The purpose of this chapter is to provide a tour of the features that make a GPL extensible, and to demonstrate how, in this context, the distinction between DSL and GPL can blur, sometimes to the point of complete disappearance.

scholarly journals Defining DSL design principles for enhancing the requirements elicitation process

2012 ◽  
Vol 22 ◽  
pp. 126-133
Author(s):  
J. Guadalupe Ramos-Díaz ◽  
Isela Navarro ◽  
Josep Silva ◽  
Gustavo Arroyo
Keyword(s):  
Social Sciences ◽  
Software Development ◽  
Design Principles ◽  
Requirements Elicitation ◽  
Domain Specific Languages ◽  
Immediate Feedback ◽  
Domain Specific ◽  
Elicitation Process ◽  
Definition Of ◽  
New Software Development

Requirements elicitation is concerned with learning and understanding the needs of users w.r.t. a new software development. Frequently the methods employed for requirements elicitation are adapted from areas like social sciences that do not include executable (prototype based on) feedback. As a consequence, it is relatively common to discover that the first release does not fit the requirements defined at the beginning of the project. Using domain-specific languages (DSLs) as an auxiliary tool for requirements elicitation is a commonly well accepted idea. Unfortunately, there are few works in the literature devoted to the definition of design principles for DSLs to be experienced in the frameworks for DSL developing such as ANTLR, Ruby, and Curry. We propose design principles for the DSL development (regardless of paradigm) which are sufficient to model the domain in a requirements phase. Further more we enunciate a new profile for the requirements analyst and a set of elicitation steps. The use of DSLs not only giveus an immediate feedback with the stake holders; it also allows us to produce part of the real code.

Ontology-Supported Design of Domain-Specific Languages

2014 ◽  
pp. 106-133
Author(s):  
István Dávid ◽  
László Gönczy
Keyword(s):  
Domain Knowledge ◽  
Knowledge Bases ◽  
Event Processing ◽  
Security Assessment ◽  
Domain Specific Languages ◽  
Specific Domain ◽  
Domain Specific ◽  
Novel Approach ◽  
Generic Language ◽  
Context Specific

This chapter introduces a novel approach for design of Domain-Specific Languages (DSL). It is very common in practice that the same problems emerge in different application domains (e.g. the modeling support for complex event processing is desirable in the domain of algorithmic trading, IT security assessment, robust monitoring, etc.). A DSL operates in one single domain, but the above-mentioned cross-domain challenges raise the question: is it possible to automate the design of DSLs which are so closely related? This approach demonstrates how a family of domain-specific languages can be developed for multiple domains from a single generic language metamodel with generative techniques. The basic idea is to refine the targeted domain with separating the problem domain from the context domain. This allows designing a generic language based on the problem and customizing it with the appropriate extensions for arbitrary contexts, thus defining as many DSLs and as many contexts as one extends the generic language for. The authors also present an ontology-based approach for establishing context-specific domain knowledge bases. The results are discussed through a case study, where a language for event processing is designed and extended for multiple context domains.

A Generic Architectural Model Approach for Efficient Utilization of Patterns

2018 ◽  
pp. 501-529 ◽  
Author(s):  
Jouni Markkula ◽  
Oleksiy Mazhelis
Keyword(s):  
Software Development ◽  
Architectural Design ◽  
Sample Collection ◽  
Application Development ◽  
Specific Domain ◽  
Domain Specific ◽  
The Core ◽  
Architectural Model ◽  
Implied Constraints ◽  
Model Approach

A software pattern describes the core of the solution to a problem that tends to (re-)occur in a particular environment. Such patterns are commonly used as a means to facilitate the creation of an architectural design satisfying the desired quality goals. In this chapter, the practical challenges of efficient usage of patterns in domain-specific software development are presented. The specific domain considered here is the mobile domain, for which is given a sample collection of potentially useful patterns. After that, a novel generic architectural model approach for organizing patterns is presented. In this approach, the identification of relevant patterns is considered as the process of reducing the set of candidate patterns by domain-implied constraints. These constraints can be incorporated in a domain-specific generic architectural model that reflects the commonalities in the solutions of the particular domain. This approach has been validated with a real company application development case.

A Generic Architectural Model Approach for Efficient Utilization of Patterns

2015 ◽  
pp. 682-709
Author(s):  
Jouni Markkula ◽  
Oleksiy Mazhelis
Keyword(s):  
Software Development ◽  
Architectural Design ◽  
Sample Collection ◽  
Application Development ◽  
Specific Domain ◽  
Domain Specific ◽  
The Core ◽  
Architectural Model ◽  
Implied Constraints ◽  
Model Approach

A software pattern describes the core of the solution to a problem that tends to (re-)occur in a particular environment. Such patterns are commonly used as a means to facilitate the creation of an architectural design satisfying the desired quality goals. In this chapter, the practical challenges of efficient usage of patterns in domain-specific software development are presented. The specific domain considered here is the mobile domain, for which is given a sample collection of potentially useful patterns. After that, a novel generic architectural model approach for organizing patterns is presented. In this approach, the identification of relevant patterns is considered as the process of reducing the set of candidate patterns by domain-implied constraints. These constraints can be incorporated in a domain-specific generic architectural model that reflects the commonalities in the solutions of the particular domain. This approach has been validated with a real company application development case.

Sign in / Sign up

Export Citation Format

Share Document