Editing Domain-specific language

{{Short description|Computer language specialized to a particular set of requirements or functionality}}
A '''domain-specific language''' ('''DSL''') is a [[computer language]] specialized to a particular application [[Domain (software engineering)|domain]]. This is in contrast to a [[general-purpose language]] (GPL), which is broadly applicable across domains. There are a wide variety of DSLs, ranging from widely used languages for common domains, such as [[HTML]] for web pages, down to languages used by only one or a few pieces of software, such as [[MUSH]] soft code. DSLs can be further subdivided by the kind of language, and include domain-specific [[markup language|''markup'' languages]], domain-specific [[modeling language|''modeling'' languages]] (more generally, [[specification language]]s), and domain-specific [[programming language|''programming'' languages]]. Special-purpose computer languages have always existed in the computer age, but the term "domain-specific language" has become more popular due to the rise of [[domain-specific modeling]]. Simpler DSLs, particularly ones used by a single application, are sometimes informally called '''mini-languages'''.

The line between general-purpose languages and domain-specific languages is not always sharp, as a language may have specialized features for a particular domain but be applicable more broadly, or conversely may in principle be capable of broad application but in practice used primarily for a specific domain. For example, [[Perl]] was originally developed as a text-processing and glue language, for the same domain as [[AWK]] and [[shell script]]s, but was mostly used as a general-purpose programming language later on. By contrast, [[PostScript]] is a [[Turing-complete]] language, and in principle can be used for any task, but in practice is narrowly used as a [[page description language]].

==Use==
The design and use of appropriate DSLs is a key part of [[domain engineering]], by using a language suitable to the domain at hand – this may consist of using an existing DSL or GPL, or developing a new DSL. [[Language-oriented programming]] considers the creation of special-purpose languages for expressing problems as standard part of the problem-solving process. Creating a domain-specific language (with software to support it), rather than reusing an existing language, can be worthwhile if the language allows a particular type of problem or solution to be expressed more clearly than an existing language would allow and the type of problem in question reappears sufficiently often. Pragmatically, a DSL may be specialized to a particular problem domain, a particular problem representation technique, a particular solution technique, or other aspects of a domain.

==Overview==
A domain-specific language is created specifically to solve problems in a particular domain and is not intended to be able to solve problems outside of it (although that may be technically possible).  In contrast, general-purpose languages are created to solve problems in many domains. The domain can also be a business area.  Some examples of business areas include:

* life insurance policies (developed internally by a large insurance enterprise)
* combat simulation
* salary calculation
* billing

A domain-specific language is somewhere between a tiny programming language<!--here seems a generic tiny language is meant, see at a target--> and a [[scripting language]], and is often used in a way analogous to a [[programming library]]. The boundaries between these concepts are quite blurry, much like the boundary between scripting languages and general-purpose languages.

===In design and implementation===
Domain-specific languages are languages (or often, declared syntaxes or grammars) with very specific goals in design and implementation. A domain-specific language can be one of a visual diagramming language, such as those created by the [[Generic Eclipse Modeling System]], programmatic abstractions, such as the [[Eclipse Modeling Framework]], or textual languages. For instance, the command line utility [[grep]] has a [[regular expression]] syntax which matches patterns in lines of text. The [[sed]] utility defines a syntax for matching and replacing regular expressions.  Often, these tiny languages can be used together inside a [[operating system shell|shell]] to perform more complex programming tasks.

The line between domain-specific languages and [[scripting language]]s is somewhat blurred, but domain-specific languages often lack low-level functions for filesystem access, interprocess control, and other functions that characterize full-featured programming languages, scripting or otherwise. Many domain-specific languages do not compile to [[byte-code]] or executable code, but to various kinds of media objects: GraphViz exports to [[PostScript]], [[GIF]], [[JPEG]], etc., where [[Csound]] compiles to audio files, and a ray-tracing domain-specific language like [[POV-Ray|POV]] compiles to graphics files.

=== Data definition languages ===
A [[data definition language]] like [[SQL]] presents an interesting case: it can be deemed a domain-specific language because it is specific to a specific domain (in SQL's case, accessing and managing relational databases), and is often called from another application, but SQL has more keywords and functions than many scripting languages, and is often thought of as a language in its own right, perhaps because of the prevalence of database manipulation in programming and the amount of mastery required to be an expert in the language.

Further blurring this line, many domain-specific languages have exposed APIs, and can be accessed from other programming languages without breaking the flow of execution or calling a separate process, and can thus operate as programming libraries.

===Programming tools===
Some domain-specific languages expand over time to include full-featured programming tools, which further complicates the question of whether a language is domain-specific or not. A good example is the [[functional language]] [[XSLT]], specifically designed for transforming one XML graph into another, which has been extended since its inception to allow (particularly in its 2.0 version) for various forms of filesystem interaction, string and date manipulation, and data typing.

In [[model-driven engineering]], many examples of domain-specific languages may be found like [[Object Constraint Language|OCL]], a language for decorating models with assertions or [[QVT]], a domain-specific transformation language. However, languages like [[Unified Modeling Language|UML]] are typically general-purpose modeling languages.

To summarize, an analogy might be useful: a Very Little Language is like a knife, which can be used in thousands of different ways, from cutting food to cutting down trees.{{Clarify|reason=It's a bit funny comparison, isn't it?|date=July 2023}} A domain-specific language is like an electric drill: it is a powerful tool with a wide variety of uses, but a specific context, namely, putting holes in things. A General Purpose Language is a complete workbench, with a variety of tools intended for performing a variety of tasks. Domain-specific languages should be used by programmers who, looking at their current workbench, realize they need a better drill and find that a particular domain-specific language provides exactly that.{{Citation needed|date=July 2023}}

==Domain-specific language topics==
===External and Embedded Domain Specific Languages===
DSLs implemented via an independent interpreter or compiler are known as ''External Domain Specific Languages''. Well known examples include TeX or AWK. A separate category known as ''Embedded (or Internal) Domain Specific Languages'' are typically implemented within a host language as a library and tend to be limited to the syntax of the host language, though this depends on host language capabilities.<ref>{{cite web |last1=Fowler |first1=Martin |last2=Parsons |first2=Rebecca |title=Domain Specific Languages |url=https://martinfowler.com/books/dsl.html |access-date=6 July 2019}}</ref>

===Usage patterns===
There are several usage patterns for domain-specific languages:<ref name='Mernik05'>{{cite journal|first1=Marjan |last1=Mernik|first2=Jan |last2=Heering|first3=Anthony M. |last3=Sloane|title=When and how to develop domain-specific languages|journal=ACM Computing Surveys|volume=37|number=4|pages=316–344|year=2005|doi=10.1145/1118890.1118892}}</ref><ref name='Spinellis01'>{{cite journal|first1=Diomidis|last1=Spinellis|url=http://www.spinellis.gr/pubs/jrnl/2000-JSS-DSLPatterns/html/dslpat.html|title=Notable design patterns for domain specific languages|journal=Journal of Systems and Software|volume=56|number=1|pages=91–99|date=February 2001|doi=10.1016/S0164-1212(00)00089-3}}</ref>

* Processing with standalone tools, invoked via direct user operation, often on the command line or from a [[Makefile]] (e.g., grep for regular expression matching, sed, lex, yacc, the [[GraphViz]] toolset, etc.)
* Domain-specific languages which are implemented using programming language macro systems, and which are converted or expanded into a host general purpose language at compile-time or realtime
* As {{anchor|eDSL}}'''embedded domain-specific language''' ('''eDSL''')<ref>{{cite journal |last1=Felleisen |first1=Matthias |last2=Findler |first2=Robert Bruce |last3=Flatt |first3=Matthew |last4=Krishnamurthi |first4=Shriram |last5=Barzilay |first5=Eli |last6=McCarthy |first6=Jay |last7=Tobin-Hochstadt |first7=Sam |title=A Programmable Programming Language |journal=Communications of the ACM |date=March 2018 |volume=61 |issue=3 |pages=62–71 |doi=10.1145/3127323 |s2cid=3887010 |url=https://cacm.acm.org/magazines/2018/3/225475-a-programmable-programming-language/fulltext |access-date=15 May 2019|url-access=subscription }}</ref> also known as an '''internal domain-specific language''', is a DSL that is implemented as a library in a "host" programming language. The embedded domain-specific language leverages the syntax, semantics and runtime environment (sequencing, conditionals, iteration, functions, etc.) and adds domain-specific primitives that allow programmers to use the "host" programming language to create programs that generate code in the "target" programming language. Multiple eDSLs can easily be combined into a single program and the facilities of the host language can be used to extend an existing eDSL. Other possible advantages using an eDSL are improved [[type safety]] and better [[Integrated_development_environment|IDE]] tooling. eDSL examples: [[SQLAlchemy]] "Core" an SQL eDSL in [[Python (programming language)|Python]], [[Java Object Oriented Querying|jOOQ]] an SQL eDSL in [[Java (programming language)|Java]], [[LINQ]]'s "method syntax" an SQL eDSL in [[C Sharp (programming language)|C#]] and [https://github.com/Kotlin/kotlinx.html kotlinx.html] an [[HTML]] eDSL in [[Kotlin (programming language)|Kotlin]].
* Domain-specific languages which are called (at runtime) from programs written in general purpose languages like [[C (programming language)|C]] or [[Perl]], to perform a specific function, often returning the results of operation to the "host" programming language for further processing;  generally, an interpreter or [[virtual machine]] for the domain-specific language is embedded into the host application (e.g. [[format string]]s, a [[Regular expression|regular expression engine]])
* Domain-specific languages which are embedded into user applications (e.g., macro languages within spreadsheets)<ref name="stinson19910416">{{Cite magazine |last=Stinson |first=Craig |date=1991-04-16 |title=Building the Perfect Spreadsheet |url=https://books.google.com/books?id=_OEk1QOJYw0C&pg=PT112 |access-date=2025-03-14 |magazine=PC |pages=101–164}}</ref>  and which are (1) used to execute code that is written by users of the application, (2) dynamically generated by the application, or (3) both.

Many domain-specific languages can be used in more than one way.{{Citation needed|date=September 2009}} DSL code embedded in a host language may have special syntax support, such as regexes in sed, AWK, Perl or JavaScript, or may be passed as strings.

===Design goals===
Adopting a domain-specific language approach to software engineering involves both risks and opportunities. The well-designed domain-specific language manages to find the proper balance between these.

Domain-specific languages have important design goals that contrast with those of general-purpose languages:

* Domain-specific languages are less comprehensive.
* Domain-specific languages are much more expressive in their domain.
* Domain-specific languages should exhibit minimal [[Redundant code|redundancy]].

===Idioms===
In programming, [[Programming idiom|idioms]] are methods imposed by programmers to handle common development tasks, e.g.:

* Ensure data is saved before the window is closed.
* Edit code whenever command-line parameters change because they affect program behavior.

General purpose programming languages rarely support such idioms, but domain-specific languages can describe them, e.g.:

* A script can automatically save data.
* A domain-specific language can parameterize command line input.

==Examples==
Examples of domain-specific programming languages include [[HTML]], [[Logo (programming language)|Logo]] for pencil-like drawing, [[Verilog]] and [[VHSIC hardware description language|VHDL]] hardware description languages, [[MATLAB]] and [[GNU Octave]] for matrix programming, [[Mathematica]], [[Maple (software)|Maple]] and [[Maxima (software)|Maxima]] for [[Computer algebra|symbolic mathematics]], [[Specification and Description Language]] for reactive and distributed systems, [[spreadsheet]] formulas and macros, [[SQL]] for [[relational database]] queries, [[Yacc|YACC]] grammars for creating [[parsers]], [[regular expressions]] for specifying [[Lexical analysis|lexers]], the [[Generic Eclipse Modeling System]] for creating diagramming languages, [[Csound]] for sound and music synthesis, and the input languages of [[GraphViz]] and [[GrGen]], software packages used for [[graph layout]] and [[graph rewriting]], [[Hashicorp Configuration Language]] used for [[Terraform (software)|Terraform]] and other [[HashiCorp|Hashicorp]] tools, [[Puppet (software)|Puppet]] also has its own [[configuration language]].

===GameMaker Language===
The GML scripting language used by [[GameMaker Studio]] is a domain-specific language targeted at novice programmers to easily be able to learn programming. While the language serves as a blend of multiple languages including [[Delphi (programming language)|Delphi]], [[C++]], and [[BASIC]]. Most of functions in that language after compiling in fact calls runtime functions written in language specific for targeted platform, so their final implementation is not visible to user. The language primarily serves to make it easy for anyone to pick up the language and develop a game, and thanks to GM runtime which handles main game loop and keeps implementation of called functions, few lines of code is required for simplest game, instead of thousands.

===ColdFusion Markup Language===
[[ColdFusion]]'s associated scripting language is another example of a domain-specific language for data-driven websites.
This scripting language is used to weave together languages and services such as Java, .NET, C++, SMS, email, email servers, http, ftp, exchange, directory services, and file systems for use in websites.

The [[ColdFusion Markup Language]] (CFML) includes a set of tags that can be used in ColdFusion pages to interact with data
sources, manipulate data, and display output. CFML tag syntax is similar to HTML element syntax.

===FilterMeister===
FilterMeister is a programming environment, with a programming language that is based on C, for the specific purpose of creating [[Photoshop]]-compatible image processing filter plug-ins; FilterMeister runs as a Photoshop plug-in itself and it can load and execute scripts or compile and export them as independent plug-ins.
Although the FilterMeister language reproduces a significant portion of the C language and function library, it contains only those features which can be used within the context of Photoshop plug-ins and adds a number of specific features only useful in this specific domain.

===MediaWiki templates===
The ''Template'' feature of [[MediaWiki]] is an embedded domain-specific language whose fundamental purpose is to support the creation of [[MediaWiki#Templates|page templates]] and the [[transclusion]] (inclusion by reference) of MediaWiki pages into other MediaWiki pages.

===Software engineering uses===
There has been much interest in domain-specific languages to improve the productivity and quality of [[software engineering]].  Domain-specific language could possibly provide a robust set of tools for efficient software engineering. Such tools are beginning to make their way into the development of critical software systems.

The Software Cost Reduction Toolkit<ref>{{cite book |first=C. |last=Heitmeyer |year=1999 |chapter=Using the SCR* toolset to specify software requirements |chapter-url=http://chacs.nrl.navy.mil/publications/CHACS/1998/1998heitmeyer-WIFT.pdf |title=Proceedings. 2nd IEEE Workshop on Industrial Strength Formal Specification Techniques |publisher=IEEE |isbn=0-7695-0081-1 |pages=12–13 |doi=10.1109/WIFT.1998.766290|s2cid=16079058 |archive-url=https://web.archive.org/web/20040719135712/http://chacs.nrl.navy.mil/publications/CHACS/1998/1998heitmeyer-WIFT.pdf |archive-date=2004-07-19 }}</ref> is an example of this. The toolkit is a suite of utilities including a specification editor to create a [[Software Requirements Specification|requirements specification]], a dependency graph browser to display variable dependencies, a [[consistency checker]] to catch missing cases in [[well-formed formula]]s in the specification, a [[model checker]] and a [[Automated theorem prover|theorem prover]] to check program properties against the specification, and an invariant generator that automatically constructs invariants based on the requirements.

A newer development is [[language-oriented programming]], an integrated software engineering [[Methodology (software engineering)|methodology]] based mainly on creating, optimizing, and using domain-specific languages.

===Metacompilers===
{{Further|Metacompiler}}
Complementing [[language-oriented programming]], as well as all other forms of domain-specific languages, are the class of compiler writing tools called [[metacompiler]]s. A metacompiler is not only useful for generating [[parser]]s and [[code generation (compiler)|code generators]] for domain-specific languages, but a [[metacompiler]] itself compiles a domain-specific [[metalanguage]] specifically designed for the domain of [[metaprogramming]].

Besides parsing domain-specific languages, metacompilers are useful for generating a wide range of software engineering and analysis tools.  The meta-compiler methodology is often found in [[Program transformation|program transformation systems]].

Metacompilers that played a significant role in both computer science and the computer industry include [[META II|Meta-II]],<ref>{{cite book |last=Shorre |first=D. V. |title=Proceedings of the 1964 19th ACM national conference |chapter=META II a syntax-oriented compiler writing language |pages=41.301–41.3011 |year=1964 |doi=10.1145/800257.808896 |s2cid=43144779 }}</ref> and its descendant [[TREE-META|TreeMeta]].<ref>{{cite journal |first1=C. Stephen |last1=Carr |first2=David A. |last2=Luther |first3=Sherian |last3=Erdmann |date=1969 |title=The TREE-META Compiler-Compiler System: A Meta Compiler System for the Univac 1108 and General Electric 645 |journal=University of Utah Technical Report RADC-TR-69-83 |url=https://apps.dtic.mil/docs/citations/AD0855122 |archive-url=https://web.archive.org/web/20200201193225/https://apps.dtic.mil/docs/citations/AD0855122 |url-status=dead |archive-date=February 1, 2020 }}</ref>

===Unreal Engine before version 4 and other games===
[[Unreal (1998 video game)|Unreal]] and [[Unreal Tournament]] unveiled a language called [[UnrealScript]]. This allowed for rapid development of modifications compared to the competitor [[Quake (video game)|Quake]] (using the [[Id Tech 2]] engine). The Id Tech engine used standard [[C (programming language)|C]] code meaning C had to be learned and properly applied, while UnrealScript was optimized for ease of use and efficiency. Similarly, more recent games have introduced their own specific languages for development. One more common example is [[Lua (programming language)|Lua]] for scripting.{{Citation needed|date=December 2019}}

===Rules engines for policy automation===
Various [[business rules engine]]s have been developed for automating policy and business rules used in both government and private industry.  [[ILOG]], [[Oracle Policy Automation]], DTRules, [[Drools]] and others provide support for DSLs aimed to support various problem domains.  DTRules goes so far as to define an interface for the use of multiple DSLs within a rule set.

The purpose of business rules engines is to define a representation of business logic in as human-readable fashion as possible.  This allows both [[subject-matter expert]]s and developers to work with and understand the same representation of the business logic.  Most rules engines provide both an approach to simplifying the control structures for business logic (for example, using declarative rules or [[decision table]]s) coupled with alternatives to programming syntax in favor of DSLs.

===Statistical modelling languages===
Statistical modelers have developed domain-specific languages such as [[R (programming language)|R]] (an implementation of the [[S (programming language)|S]] language),
[[Bayesian inference using Gibbs sampling|Bugs]], [[Just another Gibbs sampler|Jags]], and [[Stan (software)|Stan]]. These languages provide a syntax for describing a Bayesian model and generate a method for solving it using simulation.

===Generate model and services to multiple programming Languages===
Generate object handling and services based on an [[Interface description language|Interface Description Language]] for a domain-specific language such as JavaScript for web applications, HTML for documentation, C++ for high-performance code, etc. This is done by cross-language frameworks such as [[Apache Thrift]] or [[Protocol Buffers|Google Protocol Buffers]].

=== Gherkin ===
[[Cucumber (software)#Gherkin language|Gherkin]] is a language designed to define test cases to check the behavior of software, without specifying how that behavior is implemented. It is meant to be read and used by non-technical users using a natural language syntax and a [[Off-side rule|line-oriented design]]. The tests defined with Gherkin must then be implemented in a general programming language. Then, the steps in a Gherkin program acts as a syntax for method invocation accessible to non-developers.

===Other examples===
Other prominent examples of domain-specific languages include:
* [[Game Description Language]]
* [[OpenGL Shading Language]]
* [[Gradle]]
*[[ActionScript]]

==Advantages and disadvantages==
Some of the advantages:<ref name='Mernik05'/><ref name='Spinellis01'/>

* Domain-specific languages allow solutions to be expressed in the idiom and at the level of abstraction of the problem domain. The idea is that domain experts themselves may understand, validate, modify, and often even develop domain-specific language programs. However, this is seldom the case.<ref name="Freudenthal">{{cite journal|last=Freudenthal|first=Margus|title=Domain Specific Languages in a Customs Information System|journal=IEEE Software|pages=1|date=1 January 2009|doi=10.1109/MS.2009.152}}</ref>
* Domain-specific languages allow [[Computer security|validation]] at the domain level.  As long as the language constructs are safe any sentence written with them can be considered safe.{{Citation needed|date=September 2011}}
* Domain-specific languages can help to shift the development of business information systems from traditional software developers to the typically larger group of domain-experts who (despite having less technical expertise) have a deeper knowledge of the domain.<ref>{{cite journal|last1=Aram|first1=Michael|last2=Neumann|first2=Gustaf|title=Multilayered analysis of co-development of business information systems|journal=Journal of Internet Services and Applications|date=2015-07-01|volume=6|issue=1|doi=10.1186/s13174-015-0030-8|s2cid=16502371|url=http://www.jisajournal.com/content/pdf/s13174-015-0030-8.pdf|doi-access=free}}</ref>
* Domain-specific languages are easier to learn, given their limited scope.

Some of the disadvantages:

* Cost of learning a new language
* Limited applicability
* Cost of designing, implementing, and maintaining a domain-specific language as well as the tools required to develop with it ([[Integrated Development Environment|IDE]])
* Finding, setting, and maintaining proper scope.
* Difficulty of balancing trade-offs between domain-specificity and general-purpose programming language constructs.
* Potential loss of processor [[algorithmic efficiency|efficiency]] compared with hand-coded software.
* Proliferation of similar non-standard domain-specific languages, for example, a DSL used within one insurance company versus a DSL used within another insurance company.<ref>{{cite web|url=http://adams-project.org/standrts09/proceedings/miotto_vardanega_standrts09_final.pdf|title=On the integration of domain-specific and scientific bodies of knowledge in Model Driven Engineering|first=Eric|last=Miotto|access-date=2010-11-22|archive-url=https://web.archive.org/web/20110724223732/http://adams-project.org/standrts09/proceedings/miotto_vardanega_standrts09_final.pdf|archive-date=2011-07-24|url-status=dead}}</ref>
* Non-technical domain experts can find it hard to write or modify DSL programs by themselves.<ref name="Freudenthal"/>
* Increased difficulty of integrating the DSL with other components of the IT system (as compared to integrating with a general-purpose language).
* Low supply of experts in a particular DSL tends to raise labor costs.
* Harder to find code examples.

==Tools for designing domain-specific languages==
* [[JetBrains MPS]] is a tool for designing domain-specific languages. It uses [[Structure editor|projectional editing]] which allows overcoming the limits of language parsers and building DSL editors, such as ones with tables and diagrams. It implements language-oriented programming. MPS combines an environment for language definition, a [[language workbench]], and an Integrated Development Environment (IDE) for such languages.<ref>{{cite web|url=https://www.jetbrains.com/mps/|title=JetBrains MPS: Domain-Specific Language Creator}}</ref>
* [[MontiCore]] is a language workbench for the efficient development of domain-specific languages. It processes an extended grammar format that defines the DSL and generates Java components for processing the DSL documents.<ref>{{cite web|url=https://monticore.github.io/monticore/|title=MontiCore}}</ref>
* [[Xtext]] is an open-source software framework for developing programming languages and domain-specific languages (DSLs). Unlike standard parser generators, Xtext generates not only a parser but also a class model for the abstract syntax tree. In addition, it provides a fully featured, customizable Eclipse-based IDE.<ref>{{cite web|url=https://eclipse.org/Xtext/|title=Xtext}}</ref> The project was archived in April 2023.
* [[Racket (programming language)|Racket]] is a cross-platform language toolchain including native code, JIT and JavaScript compiler, IDE (in addition to supporting Emacs, Vim, VSCode and others) and command line tools designed to accommodate creating both domain-specific and general purpose languages.<ref name="languages-as-libraries">{{cite conference
  | last1 = Tobin-Hochstadt | first1 = S.
  | last2 = St-Amour | first2 = V.
  | last3 = Culpepper | first3 = R.
  | last4 = Flatt | first4 = M.
  | last5 = Felleisen | first5 = M.
  | title = Languages as Libraries
  | book-title = Programming Language Design and Implementation
  | year = 2011
  | url = http://www.ccs.neu.edu/scheme/pubs/pldi11-thacff.pdf}}
</ref><ref name="creating-languages">{{Cite news |last=Flatt |first=Matthew |title=Creating Languages in Racket |newspaper=Communications of the ACM |year=2012 |url=http://cacm.acm.org/magazines/2012/1/144809-creating-languages-in-racket |access-date=2012-04-08 }}</ref>

==See also==
* [[Language workbench]]
* [[Architecture description language]]
* [[Domain-specific entertainment language]]
* [[Language for specific purposes]]
* [[Jargon]]
* [[Metalinguistic abstraction]]
* [[Programming domain]]

==References==
{{Reflist}}

==Further reading==
*{{cite journal |first1=Marjan |last1=Mernik |first2=Jan |last2=Heering |name-list-style=amp|first3=Anthony M. |last3=Sloane |title=When and how to develop domain-specific languages |journal=ACM Computing Surveys |volume=37 |issue=4 |pages=316–344 |year=2005 |doi=10.1145/1118890.1118892 |s2cid=207158373 |url=https://ir.cwi.nl/pub/10893 }}
*{{cite journal |first=Diomidis |last=Spinellis |title=Notable design patterns for domain specific languages |journal=Journal of Systems and Software |volume=56 |issue=1 |pages=91–99 |year=2001 |doi=10.1016/S0164-1212(00)00089-3 }}
*{{cite book |first=Terence |last=Parr |title=The Definitive ANTLR Reference: Building Domain-Specific Languages |year=2007 |publisher=Pragmatic Bookshelf |isbn=978-0-9787392-5-6 }}
*{{cite journal |first=James |last=Larus |author-link=James Larus |title=Spending Moore's Dividend |issn=0001-0782 |journal=Communications of the ACM |volume=52 |issue=5 |year=2009 |pages=62–69 |doi=10.1145/1506409.1506425 |s2cid=2803479 }}
*{{cite web |url=http://www.infoq.com/news/2007/06/dsl-or-not |title=What's a Ruby DSL and what isn't? |author=Werner Schuster |publisher=C4Media |date=June 15, 2007 |access-date=2009-09-08}}
*{{cite book|first=Martin|last=Fowler|title=[[Martin Fowler (software engineer)#Domain-Specific Languages|Domain-Specific Languages]]|year=2011|publisher=Addison-Wesley |isbn=978-0-321-71294-3}}

==External links==
* "[http://catb.org/~esr/writings/taoup/html/minilanguageschapter.html Minilanguages]", ''[[The Art of Unix Programming]],'' by [[Eric S. Raymond]]
* [http://martinfowler.com/dsl.html Martin Fowler on domain-specific languages] and [http://www.martinfowler.com/articles/languageWorkbench.html Language Workbenches]. Also in [http://www.infoq.com/presentations/domain-specific-languages a video presentation]
* [http://www.st.ewi.tudelft.nl/~arie/papers/dslbib.pdf Domain-Specific Languages: An Annotated Bibliography] {{Webarchive|url=https://web.archive.org/web/20160316125655/http://www.st.ewi.tudelft.nl/~arie/papers/dslbib.pdf |date=2016-03-16 }}
* [http://www.venge.net/graydon/talks/mkc/html/index.html One Day Compilers: Building a small domain-specific language using OCaml]
* [http://www.usenix.org/publications/library/proceedings/dsl97 Usenix Association: Conference on Domain-Specific Languages (DSL '97)] and [http://www.usenix.org/publications/library/proceedings/dsl99 2nd Conference on Domain-Specific Languages (DSL '99)]
* [http://philcalcado.com/content/research_on_domain_specific_languages.html#toc-internal Internal Domain-Specific Languages]
* [https://tomassetti.me/domain-specific-languages/ The complete guide to (external) Domain Specific Languages] 
* [https://sites.google.com/site/simulationarchitecture/jeqn jEQN] {{Webarchive|url=https://web.archive.org/web/20210131053712/https://sites.google.com/site/simulationarchitecture/jeqn |date=2021-01-31 }} example of internal Domain-Specific Language for the Modeling and Simulation of Extended [[Queueing Networks]].
; Articles
* [http://www.theserverside.com/tt/articles/article.tss?l=PragmaticGen External DSLs with Eclipse technology]
* {{citation | citeseerx = 10.1.1.50.4685 | title = Building Domain-Specific Languages over a Language Framework | year = 1997 }}
* [http://www.acceleo.org/pages/using-acceleo-with-gmf/ Using Acceleo with GMF : Generating presentations from a MindMap DSL modeler] {{Webarchive|url=https://web.archive.org/web/20160730051755/http://www.acceleo.org/pages/using-acceleo-with-gmf/ |date=2016-07-30 }}
* [http://www.methodsandtools.com/archive/archive.php?id=71 UML vs. Domain-Specific Languages]
* {{citation | citeseerx = 10.1.1.156.6008 | title = Meta-model Pruning | author = Sagar Sen | year = 2009 |display-authors=etal}}

{{Types of programming languages}}
{{computer science}}
{{Authority control}}

{{DEFAULTSORT:Domain-Specific Language}}
[[Category:Domain-specific programming languages| ]]
[[Category:Programming language classification]]