Xtext has been around for a couple of years now, proving itself as a solid basis for language development in large and small scale projects. It is used in commercial products in all kinds of vertical industries and has been a basis for many research projects.

In this session we discuss where the framework is heading and how existing users will benefit from future development.

Many DSLs are convenient alternatives to hand-coding or generic data formats. Others are unique in their solution space, providing the best way, sometimes the only way, to describe a particular model or program.

But what about DSLs that have to compete with other languages? When language readability, extensibility, and efficiency of expression are key to the success of your product, what language design ideas can we bring to the table, and what techniques will make them work in Xtext?

RepreZen is an Eclipse-based API design environment, with its own DSL to describe REST APIs and supporting data types. As a new entry in the competitive and rapidly evolving API design space, it wasn't enough to offer new capabilities; we needed to raise the already high bar of usability set by other API description languages. And we needed to streamline the DSL design process for fast evolution, adding new language constructs with each beta release.

In this talk, we'll explain our language design goals, and show how we implemented some especially challenging language features, including:

• Use of a generic meta-syntax to formalize grammatical patterns in the DSL, enabling greater consistency and more centralized logic for formatting, syntax highlighting, code assist, etc. Language extensibility and platform portability are also benefits of this DSL design pattern.
• Optional fluency, which accommodates concise or fluent coding styles, according to the user's preference, through the use of optional keywords.
• Indent-based block scoping in Xtext, similar to YAML or Python.
• Flexible sequencing of language constructs for improved usability, with an option to automate canonical ordering for consistency across models.

Xtext makes it easy to define domain specific languages, but making your DSL a first class programming artifact with support for expressions and integration with Java is a hard thing if you do it from scratch.

The Xbase library is an integral part of the Xtext framework. Xbase implements the bridge from DSLs to Java. It greatly simplifies your language implementation, if you want to run your DSL on the JVM. Xbase consists of a very powerful Java-like expression grammar and implements all the necessary infrastructure to link your DSL against existing Java types, compile it to executable code and validate it against the JVM specific constraints.

In this session I want to explain how Xbase works under the covers and dive into its APIs. You will see, how to enhance your language and make it highly expressive and powerful without introducing an artificial gap to the Java platform. If you want your DSL to be a first class programming artifact, come to this session and see how to benefit best from Xbase.

Using Xtext for the first time is usually a very positive experience. Although Xtext is a complex generic framework, it is very easy to create your first Xtext-based editor, because of Xtext's smart defaults and intuitive APIs. Even with minimal initial effort, the results are quite spectacular. Unfortunately the initial excitement often turns into disillusion as soon as you use your plugin on a big project.

Many development teams hit a performance wall as their plugin gets deployed and has to support larger projects. Internally, Xtext is a complex beast. The internals are carefully hidden from the user, but understanding them is critical to understand where the performance bottlenecks come from.

At Sigasi we have built commercial tool support for complex hardware description languages (VHDL, Verilog, SystemVerilog) using the Xtext framework. Our plugin needs to handle big industrial sized projects (>400k lines of code) that include large generated files (2 to 10 MB). To handle these kinds of projects we have developed a set of techniques over the last four years.

In this talk we will cover some performance critical pieces of the Xtext framework and evaluate what can be done to optimize it (think: parallel loading, caching, fast linking, etc.). We will also discuss some workarounds that can be used if nothing else works (light-weight editors, reducing the workload of the compiler).

Scoping and Linking is often considered the most complicated part of a language infrastructure. Xtext provides you with the needed concepts to get the implementation right and with good performance. In this session you will learn how scoping is done in Xtext languages, which default implementations there are to choose from and how to implement custom scoping logic. You will also learn what the index is, how it works and how you can add even non-Xtext elements to it.

Building a modern billion transistor System-on-a-Chip (SoC) is a complex task requiring the integration of hundreds of customizable IP components and connections between them. The software to create these complex chips consists of various code-generators, performance simulators, logic synthesis tools, performance databases and place-and-route tools. Each tool typically uses its own domain specific languages to describe the input and outputs. Abstraction and good user interface are essential to successfully transform an architectural concept in to a power optimized and performance-tuned chip.

Building a software tool to efficiently configure and automate the design of an SoC is a non-trivial task. Having used XML as the intermediate persistence format; it was found it to be difficult to read and hard to bridge to legacy formats. We found that Xtext and EMF worked well to quickly glue these hardware tools together. Through its facility to specify a domain specific language that closely matched the meta-data of our existing tools, we were able use it to rapidly build a tool to handle the integration of components for large SoC designs consisting of a graphical editor, scriptable interfaces and intelligent text-based entry.

This presentation will cover:

• The lessons and challenges we encountered whilst using Xtext to specify the domain specific language in our flow
• How we used code-generators + Xbase to allow reuse of our existing Python-based validation error checks
• How we used Xtext + Xtend to build code generators and the design patterns used for providing extensible elements of our domain specific language
• The challenges to providing synchronization between various input methods: a Tcl interpreter, a graphical editor and text editor
• Our run-time validation and error checking strategy
• How we used Xpect to test our data-model utilities as well as the correctness of our parser

Four to five shorter talks about interesting applications of Xtext. If you want to give a demo about what you've done with Xtext, please send us your proposal