This book covers several topics related to domain-specific language (DSL) engineering in general and how they can be handled by means of the JetBrains Meta Programming System (MPS), an open source language workbench developed by JetBrains over the last 15 years. The book begins with an overview of the domain of language workbenches, which provides perspectives and motivations underpinning the creation of MPS. Moreover, technical details of the language underneath MPS together with the definition of the tool’s main features are discussed. The remaining ten chapters are then organized in three parts, each dedicated to a specific aspect of the topic. Part I “MPS in Industrial Applications” deals with the challenges and inadequacies of general-purpose languages used in companies, as opposed to the reasons why DSLs are essential, together with their benefits and efficiency, and summarizes lessons learnt by using MPS. Part II about “MPS in Research Projects” covers the benefits of text-based languages, the design and development of gamification applications, and research fields with generally low expertise in language engineering. Eventually, Part III focuses on “Teaching and Learning with MPS” by discussing the organization of both commercial and academic courses on MPS. MPS is used to implement languages for real-world use. Its distinguishing feature is projectional editing, which supports practically unlimited language extension and composition possibilities as well as a flexible mix of a wide range of textual, tabular, mathematical and graphical notations. The number and diversity of the presented use-cases demonstrate the strength and malleability of the DSLs defined using MPS. The selected contributions represent the current state of the art and practice in using JetBrains MPS to implement languages for real-world applications.

This book covers several topics related to domain-specific language (DSL) engineering in general and how they can be handled by means of the JetBrains Meta Programming System (MPS), an open source language workbench developed by JetBrains over the last 15 years. The book begins with an overview of the domain of language workbenches, which provides perspectives and motivations underpinning the creation of MPS. Moreover, technical details of the language underneath MPS together with the definition of the tool's main features are discussed. The remaining ten chapters are then organized in three parts, each dedicated to a specific aspect of the topic. Part I "MPS in Industrial Applications" deals with the challenges and inadequacies of general-purpose languages used in companies, as opposed to the reasons why DSLs are essential, together with their benefits and efficiency, and summarizes lessons learnt by using MPS. Part II about "MPS in Research Projects" covers the benefits of text-based languages, the design and development of gamification applications, and research fields with generally low expertise in language engineering. Eventually, Part III focuses on "Teaching and Learning with MPS" by discussing the organization of both commercial and academic courses on MPS. MPS is used to implement languages for real-world use. Its distinguishing feature is projectional editing, which supports practically unlimited language extension and composition possibilities as well as a flexible mix of a wide range of textual, tabular, mathematical and graphical notations. The number and diversity of the presented use-cases demonstrate the strength and malleability of the DSLs defined using MPS. The selected contributions represent the current state of the art and practice in using JetBrains MPS to implement languages for real-world applications.

When carefully selected and used, Domain-Specific Languages (DSLs) may simplify complex code, promote effective communication with customers, improve productivity, and unclog development bottlenecks. In Domain-Specific Languages, noted software development expert Martin Fowler first provides the information software professionals need to decide if and when to utilize DSLs. Then, where DSLs prove suitable, Fowler presents effective techniques for building them, and guides software engineers in choosing the right approaches for their applications. This book’s techniques may be utilized with most modern object-oriented languages; the author provides numerous examples in Java and C#, as well as selected examples in Ruby. Wherever possible, chapters are organized to be self-standing, and most reference topics are presented in a familiar patterns format. Armed with this wide-ranging book, developers will have the knowledge they need to make important decisions about DSLs—and, where appropriate, gain the significant technical and business benefits they offer. The topics covered include: How DSLs compare to frameworks and libraries, and when those alternatives are sufficient Using parsers and parser generators, and parsing external DSLs Understanding, comparing, and choosing DSL language constructs Determining whether to use code generation, and comparing code generation strategies Previewing new language workbench tools for creating DSLs

Software practitioners are rapidly discovering the immense value of Domain-Specific Languages (DSLs) in solving problems within clearly definable problem domains. Developers are applying DSLs to improve productivity and quality in a wide range of areas, such as finance, combat simulation, macro scripting, image generation, and more. But until now, there have been few practical resources that explain how DSLs work and how to construct them for optimal use. Software Language Engineering fills that need. Written by expert DSL consultant Anneke Kleppe, this is the first comprehensive guide to successful DSL design. Kleppe systematically introduces and explains every ingredient of an effective language specification, including its description of concepts, how those concepts are denoted, and what those concepts mean in relation to the problem domain. Kleppe carefully illuminates good design strategy, showing how to maximize the flexibility of the languages you create. She also demonstrates powerful techniques for creating new DSLs that cooperate well with general-purpose languages and leverage their power. Completely tool-independent, this book can serve as the primary resource for readers using Microsoft DSL tools, the Eclipse Modeling Framework, openArchitectureWare, or any other DSL toolset. It contains multiple examples, an illustrative running case study, and insights and background information drawn from Kleppe’s leading-edge work as a DSL researcher. Specific topics covered include Discovering the types of problems that DSLs can solve, and when to use them Comparing DSLs with general-purpose languages, frameworks, APIs, and other approaches Understanding the roles and tools available to language users and engineers Creating each component of a DSL specification Modeling both concrete and abstract syntax Understanding and describing language semantics Defining textual and visual languages based on object-oriented metamodeling and graph transformations Using metamodels and associated tools to generate grammars Integrating object-oriented modeling with graph theory Building code generators for new languages Supporting multilanguage models and programs This book provides software engineers with all the guidance they need to create DSLs that solve real problems more rapidly, and with higher-quality code.

Creating your own domain-specific languages (DSLs) is both challenging and exhilarating. DSLs give users a way to interact with your applications more effectively, and Kotlin is a fantastic language to serve as a host for internal DSLs, because it greatly reduces the pain and effort of design and development. But implementing DSLs on top of Kotlin requires understanding the key strengths of the language and knowing how to apply them appropriately. Learn to avoid the pitfalls and leverage the language while creating your own elegant, fluent, concise, and robust DSLs using Kotlin. Internal DSLs remove the burdens of implementing a full blown language compiler. The host language quickly becomes your ally to creating DSLs, but the syntax you can choose for your DSLs is limited to what the host language allows. You can work around the limitations by tactfully bending the rules and exploiting the language capabilities. Learn the power of Kotlin and ways to design with it, in the context of crafting internal DSLs Start by learning ways to exploit the flexibilities of Kotlin to make your DSLs fluent, expressive, and concise. Then pick up techniques to extend the language with domain specific properties and functions. Quickly move ahead to tie your DSL snippets into the runtime environment and context of execution of your applications. Design to prevent any non-sensical syntax in your DSL that may otherwise be valid in the host language. Finally, learn techniques to gracefully handle errors. Practice using the multiple examples that are included in each chapter. Fire up your editor and follow along each example to become proficient in designing and implementing your own internal DSLs using Kotlin. What You Need: Kotlin version 1.3 or later and your favorite Kotlin IDE or code editor.

"[The authors] are pioneers. . . . Few in our industry have their breadth of knowledge and experience." —From the Foreword by Dave Thomas, Bedarra Labs Domain-Specific Modeling (DSM) is the latest approach to software development, promising to greatly increase the speed and ease of software creation. Early adopters of DSM have been enjoying productivity increases of 500–1000% in production for over a decade. This book introduces DSM and offers examples from various fields to illustrate to experienced developers how DSM can improve software development in their teams. Two authorities in the field explain what DSM is, why it works, and how to successfully create and use a DSM solution to improve productivity and quality. Divided into four parts, the book covers: background and motivation; fundamentals; in-depth examples; and creating DSM solutions. There is an emphasis throughout the book on practical guidelines for implementing DSM, including how to identify the necessary language constructs, how to generate full code from models, and how to provide tool support for a new DSM language. The example cases described in the book are available the book's Website, www.dsmbook.com, along with, an evaluation copy of the MetaEdit+ tool (for Windows, Mac OS X, and Linux), which allows readers to examine and try out the modeling languages and code generators. Domain-Specific Modeling is an essential reference for lead developers, software engineers, architects, methodologists, and technical managers who want to learn how to create a DSM solution and successfully put it into practice.

Learn to build configuration file readers, data readers, model-driven code generators, source-to-source translators, source analyzers, and interpreters. You don't need a background in computer science--ANTLR creator Terence Parr demystifies language implementation by breaking it down into the most common design patterns. Pattern by pattern, you'll learn the key skills you need to implement your own computer languages. Knowing how to create domain-specific languages (DSLs) can give you a huge productivity boost. Instead of writing code in a general-purpose programming language, you can first build a custom language tailored to make you efficient in a particular domain. The key is understanding the common patterns found across language implementations. Language Design Patterns identifies and condenses the most common design patterns, providing sample implementations of each. The pattern implementations use Java, but the patterns themselves are completely general. Some of the implementations use the well-known ANTLR parser generator, so readers will find this book an excellent source of ANTLR examples as well. But this book will benefit anyone interested in implementing languages, regardless of their tool of choice. Other language implementation books focus on compilers, which you rarely need in your daily life. Instead, Language Design Patterns shows you patterns you can use for all kinds of language applications. You'll learn to create configuration file readers, data readers, model-driven code generators, source-to-source translators, source analyzers, and interpreters. Each chapter groups related design patterns and, in each pattern, you'll get hands-on experience by building a complete sample implementation. By the time you finish the book, you'll know how to solve most common language implementation problems.