Software Evolution course at UvA uses Rascal alpha milestone 2

Today, October 22nd 2009, we have created an Eclipse update site for Rascal. It features the second milestone of Rascal and its IDE based on Eclipse IMP.

This second milestone (alpha quality) release is prompted by the start of the Software Evolution course at the Universiteit van Amsterdam. Approximately 50 students will pioneer in using Rascal to reverse engineer a Java application, applying source code metrics, design recovery queries and smell detection queries.

The release represents another intermediate step towards a full release of Rascal. The improvements with respect to the previous alpha release are too numerous to mention. It's more stable, that's for sure.

Note that we do have a number of language syntax and semantics changes ahead of us before a first beta release of the Rascal language. The current version is ready for early experimentation though.

I would like to thank Paul Klint, Tijs van der Storm, Emilie Balland, Arnold Lankamp, Anya Helene Bagge, Claus Brabrand, Bas Basten, Joppe Kroon, Mark Hills, Jeroen van de Bos, Tobias Baanders, Erich Ocean and Vadim Zaytsev for either developing Rascal or providing valuable feedback!

The introduction of Rascal at the GTTSE Summerschool

We have introduced the Rascal language at the GTTSE Summerschool by giving a three hour tutorial and a demonstration. First of all, thanks to the organizers and the attendees. We have had the pleasure of a large and interested audience!

Rascal is a domain specific language that covers the full scope of software analysis and transformation. It is currently being developed by the Meta-Environment team.

The goal of the tutorial at GTTSE was to show the concepts, syntax and semantics of Rascal. How it can be applied to different kinds of software analysis and transformation tasks was also explained. A secondary goal was to obtain feedback from potential users of Rascal and other designers of meta programming systems on Rascal.

Please find the lecture notes here.

We can organize the feedback by splitting the audience in

• Colleagues in the meta programming area working on similar systems
• Master and PhD students in (meta-)modeling and meta-programming

.

From the first group we received encouraging remarks on the functionality of the language. Regarding the syntax and semantics our presentation left some confusion on the conceptual basis of the language. The experts want to see how features in the language map to formal concepts. They want a clear picture of how the integration of general control and data flow features with software analysis and software transformation features works on a conceptual level. Is it still conceptually simple?

The answer is yes: Rascal is a simple procedural language with structured control flow, exceptions and lexically scoped backtracking. And, all data is immutable (functional). This is the basic framework of the language. The expression sub-languages are a functional sub-set of the language. The expression operator suite unifies operations often done in either software analysis or software transformation or both. Two examples are the pattern matching operator and the set comprehension operator. Any kind of more complex feature in the Rascal language, such as rewrite rules, can easily be given a transformational semantics into the core of Rascal.

From the second group &emdash; some of who immediately downloaded the alpha evaluation version &emdash; we received usability feedback. We mentioned the design guideline of "the principle of least surprise" in our presentations. Already some syntax was surprising, like the necessity of terminating commands in the Rascal shell with a semicolon (;). As we announced, the alpha version is unfinished and contains several annoying bugs. We were happy to have found out that some people have taken the time to submit bugreports. Thanks! We are working hard to finish the Rascal implementation.

The most active bugger on our bugzilla will win a Rascal T-Shirt! The competition has started last week and a winner will be selected at X-mas time 2009.

Did you know this?

• A beta version is expected in October 2009
• Rascal covers all features of ASF+SDF and RScript
• It comes with both a commandline shell and an Eclipse/IMP-based IDE
• It already has a significant standard library that includes interfaces to the Eclipse project environment and the Eclipse Java Development Tools (JDT).

Rascal: Preparing for take-off

Five month ago I have prepared you for the arrival of our new kid on the block: Rascal. In the meantime we have not done a lot of blogging but we did do a lot of programming and documentation and Rascal is now reaching a first alpha version. If you want to have a glimpse at how the language looks like, have a look at the 100 page user manual: http://www.meta-environment.org/doc/books//analysis/rascal-manual/rascal-manual.pdf or if you prefer the html version: http://www.meta-environment.org/doc/books//analysis/rascal-manual/rascal-manual.html From this you can see that we have made major progress.

This is our elevator pitch about the main benefits offered by Rascal:

• Sophisticated built-in data types provide standard solutions for many meta-programming problems.

• Safety is achieved by finding most errors even before the program is executed and by making common errors like missing initializations or wrong pointers impossible.

• Pattern matching is used to analyze even the most complex datastructures.

• Syntax definitions make it possible to define new and existing languages and to write tools for them.

• Visiting makes it easy to traverse datastructures and to extract information from them or to synthesize results.

• Functions as values permit programming styles with high re-use.

• Generic types allow writing functions that are applicable for many different types.

• Local type inference makes local variable declarations redundant.

• Familiar syntax in a what-you-see is-what-you-get style is used even for sophisticated concepts and this makes the language easy to learn and easy to use.

• Eclipse integration makes Rascal programming a breeze. All familiar tools are at your fingertips.

Interested? Read the manual.

If you are really courageous try the alpha version that you can find at:

http://www.meta-environment.org/Meta-Environment/Rascal

We will first present Rascal at the GTTSE summer school in Braja and we will keep you posted on the initial reactions there.

Rascal, the new kid on the block

For those of you who have been following our commit messages it is clear: we are furiously working on a new system called "Rascal". But why? And what is it about? In this and subsequent messages I will try to clarify this. Why a new language? The success in solving automatic analysis and transformation problems achieved by a language like ASF+SDF makes it clear that with the increasing scale and complexity of the problems that are being solved, more language support would be welcome. We are still excited about the many good features of ASF+SDF like

• Fully user-definable syntax.
• Conditional rewriting.
• Modular language definitions.
• Fast execution.

In recent years, we have been experimenting with a tiny new language called RScript, it provides a typed relational calculus and is very useful for doing program analysis. Inspired by this, we asked ourselves the question: is it possible to keep the features of ASF+SDF and integrate them with RScript? Would this be a starting point for designing the additonal language features we are looking for? The briefest possible summary is therefore: Rascal = ASF+SDF+RScript This means that we are adding:

• A new type system, including definitions for abstract data types, higher-order functions, and more.
• New data types: lists, sets, relations.
• New control structures, i.e. comprehensions, loops, execptions.

Of course, while designing such a new language we can profit from the extensive experience the ASF+SDF user community has gained while solving analysis and transformation problems. Some of the items on the wish list are:

• Concrete and abstract datatypes.
• More efficient processing of grammar modules.
• More features for resolving ambiguities.
• Seemless integration with a host language like Java.
• Seemless integration with an IDE like Eclipse.

Typical problems to be solved:

• Concise and efficient refactoring of Java programs.
• Finding software bugs.
• Large scale software conversions and transformations.

Now that the initial requirements are becoming clear, you may wonder how Rascal looks like. That will be the topic of a next message.