Describe where the project came from. What is the historical journey of the project; who/what company wrote the project. Did it go through any significant alterations/rewrites/language changes?
Golo comes from the research activities of the Dynamid team of the CITI-INRIA Laboratory at INSA-Lyon. After experimentations in the JooFlux dynamic aspect and code injection toolkit, we realized that we could take advantage of the invokedynamic / JSR 292 to design a small, efficient and easy to hack dynamically-typed programming language for the JVM. By "easy to hack", we mean that language and runtime experiments can be approached by students and hobbyists, not just programming language design experts.
We released the first preview of Golo at the Devoxx France conference in March 2013. The language was presented in various JUGs and conferences, including Devoxx 2013 in Belgium. A fair share of such presentations have been made by community members, including:
- http://www.lavajug.org/xwiki/bin/view/Main/EventTwentySix
- http://www.rivierajug.org/xwiki/bin/view/Blog/Vendredi+28+novembre+2014+%40+Sophia%2DAntipolis++soirée+Golo
- https://speakerdeck.com/k33g/golo-petit-mais-costaud
- http://apsideblog.fr/?p=16251
- https://speakerdeck.com/jponge/golo-a-simple-post-invokedynamic-language-for-the-jvm
- (...)
Golo 1.0.0 was released in July 2014 and follows semantic versioning. The current release is Golo 2.1.0 (March 2015) and development has shifted towards Golo 3.0.0, as we shift the platform requirements to Java 8 by introducing interoperability with Java functional interfaces.
We published a first academic research paper at the PPPJ 2013 conference. We have ongoing efforts for further research publications on Golo, including language derivative experiments such as ConGolo (context-oriented programming).
Golo is supported by a small and enthusiastic community that largely goes beyond academia. Many language and runtime contributions have been done by individuals with no prior experience on programming language implementation. The community has also helped with support for Golo in Netbeans, Eclipse, popular text editors and the Gradle build tool.
Applications have been found in lightweight (web) service-oriented frameworks, IoT programming and rapid prototyping.
Provide an introductory paragraph describing what the project aims to be followed by several bullet points. The scope should allow for some flexibility, but still provide well-defined boundaries for the project.
- What is in-scope?
- What is out-of-scope?
Golo is a dynamically-typed programming language for the Java Virtual Machine.
- Golo is largely interoperable with Java and other JVM languages.
- Golo supports imperative and functional programming patterns.
- Golo explicitly wants to serve as a foundation for programming and language derivative experiments.
The introductory paragraph should clearly explain what the is and does. Think of this as an expanded elevator pitch.
- Use plain English.
- Include graphics/tables if they help with clarity.
- Focus on the technical aspects of the project.
- Is there any collaboration/usage by/with other Eclipse > projects?
- Does it build on top of other projects? What are the dependencies? Does it overlap with existing projects? Why are the needs this project meets are not met by existing Eclipse projects?
Golo is a dynamically-typed programming language for the Java Virtual Machine.
Golo is largely interoperable with Java and other JVM languages (e.g., numeric types are boxing classes from java.lang, and collection literals leverage java.util classes).
Golo supports imperative and functional programming patterns.
Golo is not a strictly object-oriented programming language: it very much resembles Go in the sense that methods are just functions applied to specific receiver types.
Golo or Java defined types can be augmented in Golo, that is, new methods can be made available.
The language features have been initially designed around the abilities of invokedynamic / JSR 292 that appeared in Java SE 7.
Golo uses ahead-of-time compilation of bytecode. While the bytecode remains stable over a program execution, the invokedynamic-based reconfigurable call sites support the adaptive dispatch mechanisms put in place for helping the HotSpot JIT to extract reasonable performance.
Golo generally exhibits good performance in micro-benchmarks for a dynamically-typed language on the JVM.
Diving into the design and implementation of a programming language is an involving task, and existing JVM languages have large codebases with rich histories. Golo explicitly wants to serve as a foundation for programming and language derivative experiments. To this end, its codebase is expected to remain concise enough to remain of pedagogical value.
Golo uses a limited set of runtime dependencies: the JavaCC parser generator, the ASM bytecode engineering library and the json-simple library. Optional runtime dependencies include JCommander for the command-line interface and Txtmark to process API documentations written in Markdown.
Golo does not currently have collaborations with other Eclipse projects beyond a community-contributed XText-based Eclipse IDE plugin. By joining the Eclipse Foundation, we expect cross-pollinisation with the wider Eclipse ecosystem.
- Why does this project want to host at Eclipse?
- What do you expect to gain by having your project at Eclipse?
- What value does the project provide to the Eclipse community and ecosystem?
In short: we want to give the project a chance to outgrow us.
Golo has reached a point where a small yet enthusiastic community gathered around it. The community is providing not just code contributions, but also conference talks and posts on the Internet.
It now makes perfect sense for the research team behind the project to move the development of Golo to a proven, vendor-neutral organization.
Eclipse has the potential to be that catalyst, as its ecosystem provides Golo with many cross-pollinisation opportunities. We envision collaborations with many projects, including:
- IDE/tooling:
- XText,
- Che,
- Orion,
- Sirius,
- Code Recommander,
- WebTools,
- Ease,
- DLTK,
- the IoT projects,
- the vert.x project.
Last but not least: the good IP management policies at the Eclipse Foundation are consistent with the policies that we already had in place. All contributions have been accepted under contributor license agreements with INSA-Lyon.
- Check the licenses that apply to the project.
- Under what license(s) will the project's artifacts be distributed? If you're not sure, contact the Eclipse Management Organization (EMO) for assistance.
- If the initial contribution is currently distributed under a different license, please make note of the current licensing terms in the "Legal Issues" section.
Golo is currently licensed under the terms of the Apache License, Version 2.0.
- Please describe any legal issues around the project and/or code.
- List the current licenses of the main code.
- List the 3rd party dependencies and associated licenses.
Golo is currently licensed under the terms of the Apache License, Version 2.0. We can make a switch to the Eclipse Public License, keep the Apache License 2.0, or move to a dual AL/EPL license. At this stage the benefits of dual licensing are unclear to us, since the EPL seems to be the "strongest" of the two licenses.
Golo is using the following 3rd-party runtime dependencies (this excludes test and build dependencies).
- JavaCC, 3-points BSD License.
- ASM, 3-points BSD License.
- JCommander, Apache License v2.0.
- Txtmark, Apache License v2.0.
- json-simple, Apache License v2.0.
Where is the code coming from? Current Eclipse project/GitHub repository or other.
http://golo-lang.org/ and https://github.com/golo-lang/golo-lang
Describe, in rough terms, what the basic scheduling of the project will be. You might, for example, include an indication of when an initial contribution should be expected, when your first build will be ready, etc. Exact dates are not required.
Our plan is to do an initial contribution within the 2 weeks of incubator acceptance.
We would appreciate if the Eclipse Foundation allowed us to enter the incubator with an initial contribution without org.eclipse.* package names. We have a number of pull-requests / features under development, and the fact that Git history is going to be reset is already a big enough issue for the development and completion of these works. We will move to org.eclipse.* packages at a later point while in the incubation. As an exception, we will not rename the gololang package which is a namespace for the Golo standard API.
We expect to develop what is currently planned for Golo 3.0.0 in the incubator, with regular milestone releases.
We would ideally propose a graduation from the incubator once feature complete, and after having used the milestone releases to get up to speed with the Eclipse processes.
- How is the project going to grow its community (users/adopters/committers)?
- Run events, attend conferences, write great documentation etc
- What are the major items to be developed?
- Couple of bullet points of major items.
The project is going to continue the efforts in growing its community, including proposing conference talks and disseminating articles. We expect the interactions with other Eclipse projects to be a fruitful growth factor, too.
The current items in development for the next release (that could be done in the Eclipse incubator) include:
- the transparent support of Java functional interfaces (the foundation of Java 8 so-called lambdas),
- the support of named arguments,
- direct anonymous function calls,
- previously deprecated APIs removal,
- easier Java class adapter generation API,
- changing a function arity using decorators,
- extension of the closure interface implementation augmentation to functional interfaces.
In future versions, we have plans to make investigations in the following areas.
- Easing embedding APIs.
- Macros.
- Lazy collections and generators.
- Adaptive / context-dependent sandboxing of Golo code.
- Exploration of opportunities on non-JVM runtimes (e.g., LLVM, CLR, JavaScript).
Select the type of source code repository the project will use as its primary host.
Git at GitHub
If you have existing publicly-accessible (ie. GitHub) source repositories for this project, list the URLs for them here.
https://github.com/golo-lang/golo-lang
- A project needs a project lead and at least one committer.
- These can change down the road.
Lead: Julien Ponge
- Need to already have committer status at Eclipse.
- If not, then they will not show up when searched for.
- These are folks who will be working on the project but are not currently Eclipse committers.
- List all involved here; if not once project is created it will require an election to add additional committers (not difficult).
All current contributors under a CLA with INSA-Lyon have been invited.
So far the following people have shown interest in joining the project at Eclipse from the start:
- Julien Ponge
- Yannick Loiseau
- Daniel Petisme
- Sylvain Desgrais
- Philippe Charrière
- Jeff Maury
- Frédéric Le Mouël
- Nicolas Stouls
- Thierry Chantier
- Franck Verrot
- Romain Lespinasse
- Guillaume Soldera
- Kel Cecil
- Alexis Thomas
We will request members from the Architecture Council to fill these.
- Mentors are members of the Eclipse Architecture Council. For help, please see Mentorship.
- New projects (i.e., incubating projects) require the supervision of at least two Mentors.
- Proposal can be opened for community review without mentors.
- Mentors must be present before we can schedule the Creation Review without mentors.
- We seek mentors on behalf of projects.
- Who is interested in this project? This could be individuals or companies.
You mentioned lots of contributions (talks,...) from the community. May be worth adding URLs to them when they are available ?