DSL

In essence, profiles were a way of producing what are now commonly referred to as domain specific languages (DSLs).

This makes it a good starting point for a large number of possible DSLs.

Arguments against Embedded DSLs are manifold. Like the idea that they make code harder to read.

DSLs are more of a tool to help a deeper and more precise conversation between different roles.

Language techniques for constructing DSLs frequently use clever tricks to supply wrapping context for your code implicitly.

Domain-Specific Languages, or DSLs, provide a convenient syntactical means for expressing goals in a given problem domain.

When building DSLs that feature quantities, you must decide on your units and (optionally) add them to the DSL to make it more readable.

In other words, DSLs try to "hide" noisy syntax using features of the underlying language to make your code more readable.

DSLs (especially internal ones) try to eliminate noisy syntax by creating contextual wrappers around related elements.

You want to enhance the fluency of your DSLs as much as possible, suggesting that you should handle cases like pluralization.

Traditionally, DSLs have had fairly limited domains.

Additionally, because DSLs are defined for particular problem domains, they capture and consequently reuse specific domain knowledge.

For business focused DSLs, the business analyst would drive the language design, working in conjunction with the technical team.

Third, textual DSLs are often more appreciated by developers, since "real developers don't draw pictures" .

Using open classes to add new methods to a built-in class is a common technique for adding expressiveness to DSLs.

MF: I don't think we have enough experience yet at DSLs being developed in a more widespread way.

InfoQ: What do you think about the role that Domain Specific Languages (DSLs) can play in modeling and executing the software architectures?

Defining a DSL is valuable because DSLs help to focus on a specific area by setting a very specific scope.

Groovy offers several features that make building DSLs easier. Support for quantities is a common requirement in DSLs.

The options that are available also tend to exercise more C-like syntax rather than expressing code using Ruby-esk DSLs.

There's still a lot to be discovered about what constitutes a good language design for DSLs.

One common technique many DSLs use (especially those targeting nondevelopers) is to leverage spoken languages.

When you hear this process discussed today, it's usually in reference to domain-specific languages, or DSLs (see Resources).

When talking about DSLs, generation and patterns, it is important to mention that you cannot completely automate patterns!

No matter what your particular reason, all DSLs should deliver a clear value to your project.

Underlying all the following techniques for constructing DSLs is the notion of implicit context.

DSLs often need to express some basic behavior which can be combersome when done in a pure declarative way.

These DSLs may be implemented separately using text or xml to represent the language.

This technique is recommended to be adopted using the following two open source textual DSLs: Chef and Puppet.

When working with DSLs, it is common to start with your goal syntax and reverse engineer backwards to figure out how to implement it.

Because of this, DSLs often are considered (executable) specification, not programming languages.

Many Grails plugins also provide DSLs to interact with the libraries or frameworks they wrap.

To make the approach introduced above feasible, you need tooling that supports the efficient definition of DSLs.

Why should you use DSLs instead of a general purposed language (GPL)?

One convenient mechanism in languages that commonly host DSLs is method missing.

DSLs offer a dedicated formalism for each domain with as few semantics and concepts as needed.

Eclipse's EMF project is also following the entity-relationship modeling technique to capture DSLs.

Grails uses this feature to provide DSLs for ORM mapping, wiring Spring beans, and other configurations.

But one can use a general modeling language like UML to document the design even if you're using DSLs.

Nevertheless, we feel it does already show the potential of using DSLs in the mobile space.

DSLs tend to create more compact code, boiling away needless verbose syntax.

External DSLs build a new language grammar, requiring tools like lexx and yacc or Antlr.

DSLs capture idiomatic domain patterns concisely and effectively.

However, these DSLs have limited flexibility.

GPLs, compared with DSLs, use a vocabulary that is simple and basic enough to describe any domain without the specifics.

Ruby is currently the most popular language for building internal DSLs.

I certainly expect that an evolutionary design is the best way to work with DSLs.

In this sense, DSLs are extremely useful in configuring a DI framework.

InfoQ: Probably most DSLs will not be created in a big bang approach, but evolve over time?

MPS is also useful in creating DSLs where you can define custom language editors and other constraints for any new language.

Thus far, I've shown two of the three context-passing techniques for fluent-interface DSLs.

InfoQ: What role does Groovy play in creating the Domain Specific Languages (DSLs)?

Another reason for preferring Ruby is the ability to create DSLs.

For developers, DSLs are another tool that can be utilized.

Now, Java (and the JVM) need to grow (and shrink) in interesting ways to support DSLs.

RJP: There is a lack of understanding of DSLs, their uses, and the tools and techniques needed to implement them.

It is common in internal DSLs to stylize the use of the base language to make the DSL more readable.

External DSLs require the addition of tools to the development environment.

Using DSLs in order to reduce the testing burden requires a thorough testing of the DSL itself.

Note: InfoQ just published a video interview with Jim Weirich, talking about rake and DSLs.

With DSLs, it's valid to question how many domains should be identified.

But there is also effort to define domain-specific languages (DSLs) using the MDA framework.

Can the use of DSLs reduce the testing burden?

If you're into DSLs, you *have* to watch this video.

DSLs, on the other hand, enforce reuse of the libraries that are utilized by the DSL implementation.

This is because there is typically a lot of commonality even between diverse DSLs.

InfoQ: I guess DSLs can address the problem domain but also the solution domain.

This is used heavily in DSLs that build internal data structures.

On the other hand, DSLs written in generic languages just work.

The benefit in this approach is in creating the DSL, and several JRuby language techniques were presented to make developing DSLs easier

These DSLs could be combinations of UML profiles, little languages or full DSLs implemented specifically for the service domain

Offers help in conceptualizing Rails and choosing between alternative modules (ORMs, routing DSLs, etc. ) in the Rails 3 timeframe

The language we built above is a DSL, a domain-specific language. Here is how I like to define DSLs