Find solution
What programming languages are 'general purpose' and 'domain specific?

What programming languages and frameworks are designed specifically for implementing other programming languages?

  • Key words are "designed" and "specifically", i.e. not general purpose languages that happen to be popular for implementing other programming languages (C, assembly, LISP). A framework in a general purpose language is ok though. Also not simply lexers and parser generators (lex, yacc). Something that helps in implementing  the semantics of the language in an interpreter/runtime/compiler/etc. It doesn't matter if the results tend to be less efficient than a custom C or assembly implementation. Tools for quickly prototyping new languages are good.

  • Answer:

    Can you specify more what of what you are trying to do? This feels like a riddle! :). I see modern language dev as consisting logically of three different layers. The syntax -> AST, AST -> Semantics, Semantics -> Runtime(Compiled or interpreted). The most vague part being the AST -> semantics part. 1) Syntax: This part feels solved to me or at least good enough. I prefer PEGs myself, but that doesn't really matter. 2) Semantics: This stage is more of conceptual stage than part of your transformation pipeline. This is the interesting part of language design now, their is diminishing returns in doing unique approaches for layer 1) and 3). I don't believe there really is a tool for this stage. Because it's a vaguely defined stage like your question. This stage really exists in part in how you do the 1) and 3) stage. 3) Runtime/Compile-time: Leveraging existing runtimes such as the JVM, or using LLVM to generate machine code, or just running the source code you generated in another language. Source to source is my favorite style these days once you get over having to debug generated code instead of the original code. Leveraging all the existing libraries with minimal binding work is just the way to go these days. On another note: Isn't the tooling of languages the most interesting part these days? Debuggers, IDE integration, Code deployment, blah blah blah.

Francois Laberge at Quora Visit the source

Was this solution helpful to you?

Other answers

The http://lambda-the-ultimate.org/node/1589 is a neat Scheme library for writing compilers. Another one is http://tinlizzie.org/ometa/, as mentioned by in one of the answers to this question. They both take different approaches to compiler construction. OMeta is a tool for experimenting with programming languages, and was born of the realisation that compilers, optimisers, and parsers are nothing more than pattern matching and transformations. And OMeta generalises this to all of them, so you can quickly prototype ideas by writing multi-pass parsers, optimisers, interpreters and compilers using the very same concepts, and compose them (OMeta core is implemented as a packrat parser combinator, with some OO for deriving parsers/compilers from base parsers/compilers). Nanopass is a compiler framework intended for teaching compiler construction, and aims to allow students to write a compiler by composing many small and focused passes that each focus on doing only one thing.

Quildreen Motta

http://www.lua.org/about.html is a tiny scripting language that is meant to be extended.  As I understand, it provides a number of standard programming language constructs and optional libraries.  You build your scripting language around that.

Jason Eisner

The http://strategoxt.org/Spoofax is made specifically for implementing programming language translators (compilers) and IDEs for them.  It is made up of a number of programming languages specifically for parsing, desugaring, transformation, name binding, and formatting.

Dobes Vandermeer

Coq, Agda and Twelf are particularly useful for working with programming languages if you're interested in exploring their formal semantics.  The common thread is the use of dependent types to represent judgments and theorems about ASTs and AST transformations (of which evaluation, compilation and typechecking are some examples). Far enough removed, the differences might be summed up by whether you prefer to use tactics, functional programming or logic programming for doing proofs. References: * http://twelf.org/wiki/Main_Page * http://www.cis.upenn.edu/~bcpierce/sf/current/ - (Benjamin Pierce's course on using Coq) * http://wiki.portal.chalmers.se/agda/pmwiki.php My personal bias for quick language experiments for a long time was Twelf because Higher Order Abstract Syntax is a wonderful tool for specifying languages without having to worry persnickety details of variable bindings (which by all rights ought to be a solved problem).  But for less ephemeral work that particular pain tends to not dominate and then it's less clear-cut which one of the three is better. It's worth learning all three.

Aleksey Kliger

Though this might be part of your 'lexer/parser generators' restrictions, PEGs are pretty interesting. You can describe grammars and semantics of your language fairly quickly in these. You also avoid having to work around the limitations of (LA)LR parsers. The most interesting and developed PEG I've run into so far is TreeTop. http://treetop.rubyforge.org/ I've used it to develop a calculator DSL in a couple of hours.

Derek Hammer

One rather obscure runtime that no one's mentioned yet is http://nekovm.org/. Your IR (intermediate representation) would then be a script* that is compiled down to the appropriate bytecode for the underlying VM. This may make the task of code generation somewhat easier. * As the website claims, it's "designed to provide a common runtime for several different languages", so the fact that the IR happens to be in a fully-capable scripting language is incidental.

Adrian Ho

Mictosoft's T4 Framework. (Another irrelevant thought: GNU' RTL... except it is not a programming language, and not stored in fully readable text; an intermediarty representation similar to how Assembly builds down to machine code.)

Chip Frank

Ocaml, F#, and the ML family of languages are well known for making implementing compilers and interpreters amazingly easy.   All languages have roots as systems designed for building logical proof systems, they have evolved into very expressive systems for manipulating strongly typed inductively defined data structures, which is what 90% of language implementation is about.

Daniel C Wang

Racket. Based on Scheme, it has an incredible array of tools for creating new programming languages as well as actual implementations of many different kinds of programming languages, while always providing access to the basic language. It is the best framework for creating and experimenting with programming languages.

Anurag Mendhekar

Load more

Related Q & A:

Just Added Q & A:

Find solution

For every problem there is a solution! Proved by Solucija.

  • Got an issue and looking for advice?

  • Ask Solucija to search every corner of the Web for help.

  • Get workable solutions and helpful tips in a moment.

Just ask Solucija about an issue you face and immediately get a list of ready solutions, answers and tips from other Internet users. We always provide the most suitable and complete answer to your question at the top, along with a few good alternatives below.