-
Notifications
You must be signed in to change notification settings - Fork 2
Mesh FAQ
Mesh is an experimental high-level, general-purpose programming language from Adobe, open-sourced under the MIT license. Its aim is to deliver an alchemical blend of functional idioms, powerful-but-ergonomic static types, and a revolutionary concurrency model built on managed mutability and STM. Initially an internal skunkworks project, we’re releasing the code to open source, where we’ll continue to develop it.
Currently Mesh might charitably be called pre-Alpha, and as such it's not yet forgiving or discoverable enough to reward exploration. It lacks everything from real documentation to standard libraries--even critical core language features are still under development. However, rapid progress is being made, and this FAQ will be updated on an ongoing basis as we do things to improve the experience of exploring and using the language, trying out demos, etc.
Well, there are already some interesting demos, including a few that (we think) show the really exciting premise of the concurrency model. There’s an interactive shell too (in fact, that’s the only compiler harness at the moment). But you’re on your own here until we finish documenting: there are very basic instructions in the repo to get the shell up and running and run demos, but be warned.
Currently the repo builds a Mesh compiler, written in Java, which sits behind an interactive shell and turns source code into JVM bytecode on the fly. There’s also a Java runtime library that implements concurrency support, built-in data structures and a bare minimum of intrinsic functions, and some third-party jars used for runtime support and demos. And then there’s some Mesh code: some library code, test code and demos of various kinds. All are in high flux.
Mesh doesn’t so much target Java as target it first. Ease of compiler and runtime development, the JVM’s robustness and performance, and the ocean of existing libraries accessible to Mesh programs via (eventual) interoperability features all make Java a great first choice for target platform. However, Mesh's abstractions are not tied to Java’s, and Mesh’s runtime support footprint is relatively small. There are active plans to support JavaScript in the near future.
Mesh has two main design goals:
- Deliver a powerful, mostly functional software construction kit in a syntax that’s friendly and scriptable, but also statically typed and precise.
- Support an STM-based concurrency model that’s easy to think about, safe, and most important, highly localized, in the sense that you can make changes to your concurrency strategy without facing sweeping, cross-cutting changes to your code as a whole.
In terms of syntax, Mesh is firmly within the curly braces/parens/semis tradition. It’s on the concise side, and follows a few invariants very strictly--for example, curly braces always mean a function literal; paren-delimited expression lists always mean a tuple literal; all functions “really” take a single argument. But if you’ve written C, Java, JavaScript, etc., etc., the syntax will be pretty easy.
At runtime, Mesh is probably closest to an eager functional language like ML or its descendants. That is, it executes statements eagerly rather than lazily, and provides a set of built-in polymorphic data types and library functions. Data is immutable, with the single exception of a polymorphic single-value container. In Mesh these are called boxes, and they come equipped with a concurrency-safe, transactional API.
Mesh’s type system is also mostly within the functional language tradition. Types are polymorphic by default and can ordinarily be inferred, rather than requiring annotation. Ordinary types are structural rather than nominal, and there is no subtyping, although polymorphic records and variants will provide many of subtyping’s benefits. Abstraction will be provided by a mechanism similar to Haskell’s type classes. And there are some other goodies in the type system that help provide an easy, scriptable coding experience without sacrificing precision.
Mesh is for developers looking to write concurrent applications quickly, easily and concisely. Beyond that, the field is open: we think there is interesting potential all over the market, from performance-heavy games to highly concurrent system applications.
Broadly speaking, Adobe wants to contribute interesting ideas and projects to the open-source community, and Mesh is part of our effort to do simply that. More specifically, we want to participate in the ferment of creative activity that’s currently taking place in the world of language design—Mesh aspires to be part of the overall trend in which formerly esoteric or academic features and ideas are finding their way into the mainstream, where the marketplace of working developers are discovering their real, practical power. In particular, we really like this concurrency model, have a lot of ideas for how it might be used, and feel that a fleshed-out language is the best way to showcase it.
Over the next few months, Mesh will continue in pre-Alpha development until the core language is stable. The phase change into Alpha will occur when the language is complete enough that Mesh programs aren’t distorted by the absence of core features. For example, the current version lacks proper polymorphic records and variants, and overloading—meaning that the language that is usable today is sufficiently lacking, and sufficiently different than the ideal final language, that we don’t yet encourage you to spend a lot of time writing in it.
We recommend holding off on the getting started until the Alpha phase change mentioned above is reached. At this point, we’ll have not only a more complete language, but documentation and tutorials that will make getting started... pleasant. That said, example code can already be found in the src/script subdirectory of this repo; the README in that directory contains a bare minimum of descriptive details and instructions. Also, the interactive shell will let you just try expressions—again, though, a proper tutorial for what might be interesting to try there doesn’t yet exist.
The Google Group meshlang will be the place for questions and discussion, though probably won't become really active until the Alpha phase change mentioned above. For issues, we'll be using GitHub’s native issue tracking system.
The #meshlang IRC channel on chat.freenode.net will also be used for basic realtime communication for the team.