Results 1 - 10
of
34
WebDSL: A Case Study in Domain-Specific Language Engineering
"... Abstract. The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This requires techno ..."
Abstract
-
Cited by 46 (14 self)
- Add to MetaCart
Abstract. The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This requires technology for designing and implementing DSLs, but also a methodology for using that technology. That is, a collection of guidelines, design patterns, and reusable DSL components that show developers how
SugarJ: Librarybased syntactic language extensibility
- In Proceedings of Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA). ACM
, 2011
"... Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot be used with the same ease as the main extension mechanism of the programming language—libraries. Sugar libraries are a novel approach for syntactically extending a programming l ..."
Abstract
-
Cited by 38 (14 self)
- Add to MetaCart
(Show Context)
Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot be used with the same ease as the main extension mechanism of the programming language—libraries. Sugar libraries are a novel approach for syntactically extending a programming language within the language. A sugar library is like an ordinary library, but can, in addition, export syntactic sugar for using the library. Sugar libraries maintain the composability and scoping properties of ordinary libraries and are hence particularly well-suited for embedding a multitude of domain-specific languages into a host language. They also inherit self-applicability from libraries, which means that sugar libraries can provide syntactic extensions for the definition of other sugar libraries. To demonstrate the expressiveness and applicability of sugar libraries, we have developed SugarJ, a language on top of Java, SDF and Stratego, which supports syntactic extensibility. SugarJ employs a novel incremental parsing technique, which allows changing the syntax within a source file. We demonstrate SugarJ by five language extensions, including embeddings of XML and closures in Java, all available as sugar libraries. We illustrate the utility of selfapplicability by embedding XML Schema, a metalanguage to define XML languages.
Verifiable composition of deterministic grammars
- In Proc. of ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM
, 2009
"... There is an increasing interest in extensible languages, (domain-specific) language extensions, and mechanisms for their specification and implementation. One challenge is to develop tools that allow non-expert programmers to add an eclectic set of language extensions to a host language. We describe ..."
Abstract
-
Cited by 20 (5 self)
- Add to MetaCart
(Show Context)
There is an increasing interest in extensible languages, (domain-specific) language extensions, and mechanisms for their specification and implementation. One challenge is to develop tools that allow non-expert programmers to add an eclectic set of language extensions to a host language. We describe mechanisms for composing and analyzing concrete syntax specifications of a host language and extensions to it. These specifications consist of context-free grammars with each terminal symbol mapped to a regular expression, from which a slightly-modified LR parser and context-aware scanner are generated. Traditionally, conflicts are detected when a parser is generated from the composed grammar, but this comes too late since it is the non-expert programmer directing the composition of independently developed extensions with the host language. The primary contribution of this paper is a modular analysis that is performed independently by each extension designer on her extension (composed alone with the host language). If each extension passes this modular analysis, then the language composed later by the programmer will compile with no conflicts or lexical ambiguities. Thus,
Declarative access control for WebDSL: Combining language integration and separation of concerns
- In Web Engineering, 2008. ICWE’08. Eighth International Conference on
, 2008
"... In this paper, we present the extension of WebDSL, a domain-specific language for web application development, with abstractions for declarative definition of access con-trol. The extension supports the definition of a wide range of access control policies concisely and transparently as a separate c ..."
Abstract
-
Cited by 20 (9 self)
- Add to MetaCart
(Show Context)
In this paper, we present the extension of WebDSL, a domain-specific language for web application development, with abstractions for declarative definition of access con-trol. The extension supports the definition of a wide range of access control policies concisely and transparently as a separate concern. In addition to regulating the access to pages and actions, access control rules are used to infer navigation options not accessible to the current user, pre-venting the presentation of inaccessible links. The exten-sion is an illustration of a general approach to the design of domain-specific languages for different technical domains to support separation of concerns in application develop-ment, while preserving linguistic integration. This approach is realized by means of a transformational semantics that weaves separately defined aspects into an integrated imple-mentation. 1
T.: Language composition untangled
- In: Proceedings of the 12th Workshop on Language Descriptions, Tools and Applications (LDTA) (2012
"... Abstract In language-oriented programming and modeling, software developers are largely concerned with the definition of domain-specific languages (DSLs) and their composition. While various implementation techniques and frameworks exist for defining DSLs, language composition has not obtained enou ..."
Abstract
-
Cited by 19 (6 self)
- Add to MetaCart
(Show Context)
Abstract In language-oriented programming and modeling, software developers are largely concerned with the definition of domain-specific languages (DSLs) and their composition. While various implementation techniques and frameworks exist for defining DSLs, language composition has not obtained enough attention and is not well-enough understood. In particular, there is a lack of precise terminology for describing observations about language composition in theory and in existing language-development systems. To clarify the issue, we specify five forms of language composition: language extension, language restriction, language unification, self-extension, and extension composition. We illustrate this classification by various examples and apply it to discuss the performance of different language-development systems with respect to language composition. We hope that the terminology provided by our classification will enable more precise communication on language composition.
Pure and declarative syntax definition: paradise lost and regained
, 2010
"... year = {2010}, booktitle = {Proceedings of Onward! 2010}, publisher = {ACM}, ..."
Abstract
-
Cited by 16 (2 self)
- Add to MetaCart
(Show Context)
year = {2010}, booktitle = {Proceedings of Onward! 2010}, publisher = {ACM},
Designing Syntax Embeddings and Assimilations for Language Libraries
"... Abstract. Language libraries extend regular libraries with domain-specific notation. More precisely, a language library is a combination of a domain-specific language embedded in the general-purpose host language, a regular library implementing the underlying functionality, and an assimilation trans ..."
Abstract
-
Cited by 14 (2 self)
- Add to MetaCart
(Show Context)
Abstract. Language libraries extend regular libraries with domain-specific notation. More precisely, a language library is a combination of a domain-specific language embedded in the general-purpose host language, a regular library implementing the underlying functionality, and an assimilation transformation that maps embedded DSL fragments to host language code. While the basic architecture for realizing language libraries is the same for all applications, there are many design choices to be made in the design of a particular combination of library, guest language syntax, host language, and assimilation. In this paper, we present a systematic analysis of the design space for syntax embeddings and assimilations for the realization of language libraries. The contribution of this paper is an overview of the state-of-the-art providing insight in the design space and research questions in language library realization, in particular, the identification of research issues for realizing an independently extensible language library framework. 1
Mixing source and bytecode. A case for compilation by normalization
- Object-Oriented Programing, Systems, Languages, and Applications (OOPSLA 2008
, 2008
"... Language extensions increase programmer productivity by providing concise, often domain-specific syntax, and sup-port for static verification of correctness, security, and style constraints. Language extensions can often be realized through translation to the base language, supported by pre-processo ..."
Abstract
-
Cited by 13 (9 self)
- Add to MetaCart
(Show Context)
Language extensions increase programmer productivity by providing concise, often domain-specific syntax, and sup-port for static verification of correctness, security, and style constraints. Language extensions can often be realized through translation to the base language, supported by pre-processors and extensible compilers. However, various kinds of extensions require further adaptation of a base compiler’s internal stages and components, for example to support sep-arate compilation or to make use of low-level primitives of the platform (e.g., jump instructions or unbalanced synchro-nization). To allow for a more loosely coupled approach, we propose an open compiler model based on normalization steps from a high-level language to a subset of it, the core language. We developed such a compiler for a mixed Java and (core) bytecode language, and evaluate its effective-ness for composition mechanisms such as traits, as well as statement-level and expression-level language extensions.
Defining code-injection attacks
- In ACM POPL
, 2012
"... This paper shows that existing definitions of code-injection attacks (e.g., SQL-injection attacks) are flawed. The flaws make it possible for attackers to circumvent existing mechanisms, by supplying code-injecting inputs that are not recognized as such. The flaws also make it possible for benign in ..."
Abstract
-
Cited by 8 (1 self)
- Add to MetaCart
This paper shows that existing definitions of code-injection attacks (e.g., SQL-injection attacks) are flawed. The flaws make it possible for attackers to circumvent existing mechanisms, by supplying code-injecting inputs that are not recognized as such. The flaws also make it possible for benign inputs to be treated as attacks. After describing these flaws in conventional definitions of code-injection attacks, this paper proposes a new definition, which is based on whether the symbols input to an application get used as (normalform) values in the application’s output. Because values are already fully evaluated, they cannot be considered “code ” when injected. This simple new definition of code-injection attacks avoids the problems of existing definitions, improves our understanding of how and when such attacks occur, and enables us to evaluate the effectiveness of mechanisms for mitigating such attacks.
Domain-specific languages for composable editor plugins
- Language Descriptions, Tools, and Applications (LDTA 2009), ENTCS
, 2009
"... Modern IDEs increase developer productivity by incorporating many different kinds of editor services. These can be purely syntactic, such as syntax highlighting, code folding, and an outline for navigation; or they can be based on the language semantics, such as in-line type error reporting and reso ..."
Abstract
-
Cited by 7 (4 self)
- Add to MetaCart
(Show Context)
Modern IDEs increase developer productivity by incorporating many different kinds of editor services. These can be purely syntactic, such as syntax highlighting, code folding, and an outline for navigation; or they can be based on the language semantics, such as in-line type error reporting and resolving identifier declarations. Building all these services from scratch requires both the extensive knowledge of the sometimes complicated and highly interdependent APIs and extension mechanisms of an IDE framework, and an in-depth understanding of the structure and semantics of the targeted language. This paper describes Spoofax/IMP, a meta-tooling suite that provides high-level domain-specific languages for describing editor services, relieving editor developers from much of the framework-specific programming. Editor services are defined as composable modules of rules coupled to a modular SDF grammar. The composability provided by the SGLR parser and the declaratively defined services allows embedded languages and language extensions to be easily formulated as additional rules extending an existing language definition. The service definitions are used to generate Eclipse editor plugins. We discuss two examples: an editor plugin for WebDSL, a domain-specific language for web applications, and the embedding of WebDSL in Stratego, used for expressing the (static) semantic rules of WebDSL.