Sometimes it’s easy to forget how much Grace has changed over the last five years. Most of the major language design decisions were made early, and since then … what?

Quite a lot, actually! I just had cause to re-visit some binary tree code that I wrote in the summer of 2015 as an example for a data structures class. It’s nothing special, but does illustrate the power of Grace’s λ-expressions, which, unlike those in Java, let you close over variables, not just constants. We can therefore use a λ-expressions to abstract over the command that is required to update a field in a parent node to refer to a new child. I described this “trick” in a previous post on this blog.

Of course, the original code no longer compiled; too much has changed. What exactly? Comparing the two versions in git gives us a good summary:

• The “math” module has been removed. Mathematical operations are now methods on numbers.
• The “random” module has been added, to give access to various random number generators.
• factory method has been replaced by class.
• Type parameters are now enclosed in double square brackets, rather than in angle brackets.
• Interfaces are defined with the reserved word interface, rather than with type
• inherits has been changed to inherit
• The standard dialect now defines Proceduren and Functionn instead of Blockn
• Traits have been added to Grace, and the standard dialect redefined using them. This makes it possible to combine and re-combine dialects, and pieces of dialects.
• The == operator is no longer defined on graceObject and inherited by all other objects. Instead, graceObject defines isMe(_) and myIdentityHash, and a trait identityEquality is available for reuse to define the ==, ≠ and hashmethods.
• Patterns and types are somewhat less confused than formerly. Arbitrary patterns can be used in match statements, but not in type declarations.
• We have rigorously defined Grace’s indentation rules, and minigrace is a bit pickier about correct indentation that it used to be.
• Square brackets now denote Sequence constructors. ”Lineups”, are gone, collections now understand >> and << for pipelining.
• Variable-arity methods are no longer part of Grace. Instead, the programmer can define independent methods with the same name and different numbers of arguments—so sequence, sequence(_), and sequence(_,_) can co-exist.

There are probably some other language changes too, and certainly additions to the libraries, but these are the changes that made it necessary to modify formerly-correct code from 2015 so that it compiles and runs in 2020.

The last change—eliminating variable-arity methods—although small in itself, is probably the change with the biggest consequences, because it necessitated changing the interface for constructing collections.

All of these changes have a rationale. In some cases, the change was made for consistency, in others, to make Grace easier to teach. In the case of trait use, it was to make reuse simpler and more powerful than was possible with inheritance alone. Grace continues to evolve, but I feel that we are converging on a language that is pleasant to use, communicates well, and has as much expressiveness (in its target space) as its competitors.

Grace will be at ECOOP2019 in London this month, when we’re presenting a paper “Transient Typechecks are (almost) Free” about the Moth Grace VM build with Graal.

Grace will be at SPLASH 2018 in Boston this year. In particular, on Sunday 4 November, there is a Grace Workshop that will look at the past, present, and future of the project.

Of most general interest (i.e. to people working on other languages)
there is a session between 13:30 and 15:00 on Gradual Typing where Benjamin Chung, Benjamin Greenman, and Tim Jones will present different perspectives from their research on Gradual Typing.
Then we hope for interesting, insightful, or at least amusing discussions after the 15:00-15:30 break.

Tim Jones’ PhD thesis on Grace’s design – Classless Object Semantics is now in VUW’s research repository.

If you’re interested in this kind of stuff, it’s a surprisingly good read…

Objects have been categorised into classes that declare and implement their behaviour ever since the paradigm of object-orientation in programming languages was first conceived. …

This dissertation investigates the foundational nature of the class in the object-oriented paradigm from the perspective of an ‘objects-first’, classless language. Using the design of theoretical models and practical implementations of these designs as extensions of the Grace programming language, we demonstrate how objects can be used to emulate the functionality of classes, and the necessary trade-offs of this approach.