Languages as libraries

Tobin-Hochstadt, Sam; St-Amour, Vincent; Culpepper, Ryan; Flatt, Matthew; Felleisen, Matthias

doi:10.1145/1993316.1993514

Cited by 52 publications

(34 citation statements)

References 40 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The idea of offering facilities to add syntactic constructions to a language remotes to the Lisp language and its dialects, such as Scheme and Racket [9]. These languages use the same notation for data and program, S-expressions, thus they allow the implementation of a flexible and powerful macro-system.…”

Section: Parsing Of Extensible Languagesmentioning

confidence: 99%

“…Despite the various methods for implementing DSLs, extensible languages seem to have several advantages over other approaches [8][9][10]. One of the advantages is the possibility of implementing DSLs in a modular way.…”

Section: Introductionmentioning

confidence: 99%

“…For example, Erdweg et al show how DSLs can be implemented using the extensible language SugarJ [8], by means of syntax units designated as sugar libraries, which specify a new syntax for a domain concept. Tobin-Hochstadt et al also discuss the advantages of implementing DSLs by means of libraries [9].…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

An on-the-fly grammar modification mechanism for composing and defining extensible languages

Reis¹,

Iorio²,

Bigonha³

2015

Computer Languages, Systems & Structures

View full text Add to dashboard Cite

a b s t r a c tAdaptable Parsing Expression Grammar (APEG) is a formal method for defining the syntax of programming languages. It provides an on-the-fly mechanism to perform modifications of the syntax of the language during parsing time. The primary goal of this dynamic mechanism is the formal specification and the automatic parser generation for extensible languages. In this paper, we show how APEG can be used for the definition of the extensible languages SugarJ and Fortress, clarifying many aspects of the syntax of these languages. We also show that the mechanism for on-the-fly modification of syntax rules can be useful for defining grammars in a modular way, implementing almost all types of language composition in the context of specification of extensible languages.

show abstract

Section: Parsing Of Extensible Languagesmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

An on-the-fly grammar modification mechanism for composing and defining extensible languages

Reis¹,

Iorio²,

Bigonha³

2015

Computer Languages, Systems & Structures

View full text Add to dashboard Cite

show abstract

“…Compile-time metaprogramming provides a way to animate external DSLs, making them able to analyze and possibly influence the enclosing program [39].…”

Section: External Domain-specific Languagesmentioning

confidence: 99%

“…Across languages and paradigms, this sort of metaprogramming has been proven immensely useful, acting as an enabling force behind a number of programming techniques, such as: language virtualization (overloading/overriding semantics of the original programming language) [11], embedding of external domain-specific languages (tight integration of external DSLs into the host language) [39,47], self-optimization (self-application of optimizations based on analysis of the program's own code) [34], and boilerplate generation (automatizing repetitive patterns which cannot be readily abstracted away by the underlying language) [29,35].…”

mentioning

confidence: 99%

Scala macros: let our powers combine!

Burmako

2013

Proceedings of the 4th Workshop on Scala

View full text Add to dashboard Cite

Compile-time metaprogramming has been proven immensely useful enabling programming techniques such as language virtualization, embedding of external DSLs, self-optimization, and boilerplate generation amongst many others.In the recent production release of Scala 2.10 we have introduced macros, an experimental facility which gives its users compile-time metaprogramming powers. Alongside of the mainline release of Scala Macros, we have also introduced other macro flavors, which provide their users with different interfaces and capabilities for interacting with the Scala compiler.In this paper, we show how the rich syntax and static types of Scala synergize with macros, through a number of real case studies using our macros (some of which are production systems) such as language virtualization, type providers, materialization of type class instances, type-level programming, and embedding of external DSLs. We explore how macros enable new and unique ways to use pre-existing language features such as implicits, dynamics, annotations, string interpolation and others, showing along the way how these synergies open up new ways of dealing with software development challenges.

show abstract

Frameworks compiled from declarations: a language‐independent approach

2016

View full text Add to dashboard Cite

Programming frameworks are an accepted fixture in the object-oriented world, motivated by the need for code reuse, developer guidance and restriction. A new trend is emerging where frameworks require domain experts to provide declarations using a domain-specific language, influencing the structure and behaviour of the resulting application. These mechanisms address concerns such as user privacy. Although many popular open platforms such as Android are based on declaration-driven frameworks, current implementations provide ad hoc and narrow solutions to concerns raised by their openness to non-certified developers. Most widely used frameworks fail to address serious privacy leaks and provide the user with little insight into application behaviour. To address these shortcomings, we show that declaration-driven frameworks can limit privacy leaks, as well as guide developers, independently from the underlying programming paradigm. To do so, we identify concepts that underlie declaration-driven frameworks and apply them systematically to an object-oriented language, Java and a dynamic functional language, Racket. The resulting programming framework generators are used to develop a prototype mobile application, illustrating how we mitigate a common class of privacy leaks. Finally, we explore the possible design choices and propose development principles for developing domain-specific language compilers to produce frameworks, applicable across a spectrum of programming paradigms.Domain-specific languages themselves are a well-established tool for increasing programmer efficacy as well as bridging the communication gap between application developers and domain experts [7][8][9][10]. This work aims in part to explore the link between DSLs and application programming frameworks.The complexity of DSLs used to parameterise frameworks varies greatly: we find examples ranging from simple lists of permissions as in Android to relatively rich DSLs used to describe the structure of the application (as in QtBuilder [11]). For example, the Manifest file required by Android applications declares which resources the application may use [3]. Resources are any sources or sinks, whether real devices (e.g. camera and microphone) or virtual ones (e.g. address book and the Internet). Such declarations allow the framework to better answer emerging challenges such as privacy concerns, potentially giving a user insight into how their sensitive information is used. In this work, we focus on these declaration-driven frameworks as applied to the problem of user data privacy. This is but one example where such declaration-driven frameworks are a fruitful technique: elsewhere, they have been applied to quality-of-service concerns [12], automatic exception management [13] or drive application simulation before deployment [14]. We restrict our discussion to user privacy, because it is a timely and relevant problem for which the benefits of declaration-driven frameworks are clear, as we will motivate in the rest of this article.Recently, we are seein...

show abstract

Languages as libraries

Cited by 52 publications

References 40 publications

An on-the-fly grammar modification mechanism for composing and defining extensible languages

An on-the-fly grammar modification mechanism for composing and defining extensible languages

Scala macros: let our powers combine!

Frameworks compiled from declarations: a language‐independent approach

Contact Info

Product

Resources

About