— a lightweight dynamic language for the JVM.

back to the front page

 Golo 1.0.0 is here!

Beautiful, isn't it?

We are very glad to announce the release of Golo 1.0.0 exactly 2 years after the the initial commit!

Releasing a version 1.0.0 is always an important achievement, so let’s take a few paragraphs to reflect on the journey.

How did we get there?

Golo wasn’t exactly meant to turn into a real project. It all started back in July 2012 as a summer side-project while some Dynamid research group members further explored the capabilities of invokedynamic on the JVM. Playing with the implementation of a simple dynamically-typed language just made a lot of sense, especially as few languages had working invokedynamic-based runtimes back then.

As the development progressed we quickly realised that we should also eventually share it with the rest of the world. Performance was looking good even with a very simple runtime design, thanks to invokedynamic.

As researchers in the field of middleware for dynamic systems, we often played with software modifications at runtime. We were also used to designing APIs, but in either case there is always a point where certain problems are better investigated through language extensions rather than hacks on top of them.

Yet, language design and implementation remains a field of specialists. Picking an existing language and making modifications is complex, and certainly complex enough to overflow the duration of a typical student reseach project. The code base of a typical popular JVM language can be quite intimidating.

That’s why we opted to pursue work on Golo with the following objectives in mind:

  1. explore the capabilities of invokedynamic to design a whole language around it,
  2. design a simple language that would be suitable to experiment with derivatives,
  3. disseminate and share our work outside of the academic research circles.

Looking back on 2 years of work

Thanks to Henri Gomez for the following Gource video!

It took 2 years to reach this 1.0.0 version, but digging through the Git history reveals that the active days count is roughly of 1 year and that Golo is nearly a one-man show:

$ git summary

 project  : gololang
 repo age : 2 years
 active   : 374 days
 commits  : 1404
 files    : 352
 authors  :
  1303	Julien Ponge            92.8%
    28	Philippe Charrière     2.0%
    18	Daniel Petisme          1.3%
    16	Kel Cecil               1.1%
    16	David Festal            1.1%
     8	Guillaume Grossetie     0.6%
     5	Jeff Maury              0.4%
     4	Sylvain                 0.3%
     3	Yannick Loiseau         0.2%
     1	Franck Verrot           0.1%
     1	Thierry Chantier        0.1%
     1	Dan Allen               0.1%

Note: while Dynamid members Frédéric Le Mouel and Nicolas Stouls do not appear in the commit history, they still have had lots of inputs.

Implementing Golo is actually a lot of work, especially as it is not backed by any research grant. It mainly exists because the CITI laboratory supports such experiments, but the lack of official funding is always a limitating factor in modern research.

Let us now see how Golo has met its objectives.

Exploring invokedynamic

Golo is the first language that was designed around invokedynamic. We accumulated a fair share of experience around what it can do well.

We explored certain language features implementation patterns, both in terms of ability to be implemented and performance. This is an area where we gathered significant experience that is worth publications for the research community.

That being said the limited resources that we could allocate to Golo mean that we only found time to publish 1 research paper at PPPJ’2013. This is not enough, and we will devote time for writing new publications now that version 1.0.0 has been delivered. Research work has to be evaluated through peer-reviewed publications, and we look forward to do so!

Making a hackable language

Contributors without previous language implementation experience helped us on some language features, so it seems like Golo is easy to play with.

There are 2 ongoing language research experiments based on Golo. One is on the runtime implementation and is being developed by our team in Lyon. The other one is a language extension by one of our student in Shangai under the supervision of Frédéric Le Mouel. Again, the student is on a limited time frame and he had no previous language work experience, but Golo was simple enough for him to get up to speed on time to contribute (e.g., design, implement and validate a solution to his research problem).

In both cases the projects are based on Golo as a simple language, and while they won’t seek for feature completeness, they will support research work and experimentations.

Disseminate outside the Ivory Tower.

In the CITI laboratory we are convinced that good research work also includes dissemination and transfer. By sharing Golo with the rest of the world, we took an approach of not just pushing the code to GitHub, but to also welcome and encourage contributions.

The results are clearly great: we have 11 external contributors under a contributor license agreement with INSA-Lyon. Among these 11 contributors, 1 is a fellow academic (Yannick Loiseau) while the other 10 are enthusiasts with limited to no previous language implementation experience.

David Festal helped us on the parser and Netbeans language support as his company Serli allocated him some time to help us in the early stages of the Golo development.

Last but not least: contributions did not stop to code as Philippe Charrière and Daniel Petisme did several talks in Java User Groups and conferences (Devoxx France, Soft Shake, etc).

What’s next?

We are commited to pursue the development of Golo beyond this release, but ultimately what’s next for Golo is also a lot about where you will push it :-)

You can already expect new features to appear soon, including:

Big Big thanks to…

First and foremost, huge thanks to the CITI-INRIA Laboratory at INSA-Lyon for letting us take some time on doing this (not funded) development in the open.

We wouldn’t have reached this important milestone without the support of our awesome contributors:

Guillaume Poyet designed our iconic logo.

2 companies helped along the way: Serli and Ninja Squad.

The wider community also includes Marcin Erdmann for the Gradle plugin, Romain Lespinasse for the Homebrew integration and Henri Gomez for the RPM packaging.

We do not forget our initial testers before we released Golo in the open at Devoxx France 2013: Pierre Colomb, Olivier Coupelon, Cédric Exbrayat, Frédéric Le Mouel, Nicolas Stouls, Henri Gomez, Julien Viet, Philippe Charrière, Ludovic Champenois, Thierry Chantier, Daniel Petisme, David Gageot, David Festal, Gildas Cuisinier, Thomas Maurel, Yannick Loiseau, Alexis Plantin, Sylvain Desgrais, William Guyot, Agnès Crépet, Cyril Lacote.

Last but not least, thanks to all of you that have an opinion on Golo. We like you even if you don’t like us :-)

Until next time, have fun!

comments powered by Disqus

Copyright © 2012 – 2016 INSA-Lyon and contributors.

Privacy Policy | Terms of Use | Copyright Agent | Eclipse Public License | Legal Resources