Strange Loop Emerging Languages Camp Recap: Julia, Grace, Rust, and a Bandicoot


strangeloop conference[Image via The Julia Language]

This year, the Emerging Languages Camp was the pre-conference for Strange Loop, the developer conference held annually in St. Louis. Recaps for Strange Loop are forthcoming, but here are my notes from the precon sessions.

Transpiling into Javascript

  • Languages: Javascript, coffeescript
  • Speaker: Jeremy Ashkenas (t gh), Interactive News at the New York Times, creator of coffeescript + backbone.js

This whole "compiling" into another language is pretty new, except for C++ which started out by compiling into c code. Recently though, we've gotten these strong solid VMs to build upon; it's just not worth it to build your own VM.

One way to transpile is is to start by switching one simple symbol, then expand out into new keywords and flow controls.

There's a site altjs.org that lists a whole bunch of languages that compile into js.

Be deliberate about where you deviate and what you preserve – this probably doesn't apply too much to porting an existing language to a different vm though.

Not everything can be straight transpiled. For example adding negative indices to something running on js would require changing all array accesses to be: array[x<0 ? array.length-x : x], which would be pretty unpleasant. If you can figure out at compile time though, you're good to go.

The reason that coffeescript compiles readable code is that it makes you feel safe since you read/debug it.

All languages have this duality where they're trying to be readable to both computers and developers. Transpilers can help us move towards the human-readable side of things.

 

Bandicoot: Code Reuse for the Relational Model

  • Language: Bandicoot
  • Speakers: Ostap Cherkashin (t gh), Bandicoot co-founder and software enginner, and Julius Chrobak (t), Bandicoot co-founder and database engineer

Bandicoot is a new language for dealing with relational algebra and sets. One of the big things they talked about was reusability. It didn't seem to me though that this was any better than ActiveRecord's lazy query syntax or LYNQ, plus you have to use a different language.

 

Elm: Making the Web Functional

  • Language: Elm
  • Speaker: Evan Czaplicki (gh), Elm creator

Elm is a pretty sweet language for doing web development. The most impressive part is the declarative/functional way that it does gui. It has built in markdown support so if you want to throw some text in, you can format it that way.

As a functional language, everything is immutable; however, if you have something like the mouse position, or time, which changes, it's stored in what is called a signal. You then can take any of your normal functions, and use a method called lift to convert that into a signal, with another signal, so you just pass the mouse position or time into your sweet function that you originally used to draw everything, and your app now responds to mouse position. Check out the interactive editor or any of the other examples. They're all simple, and easy. This is a serious thing: http://en.wikipedia.org/wiki/Reactive_programming, but the first time that I've ever really seen reactive programming that blew the other methods out of the water.

The Reemergence of Datalog

  • Language: Datalog
  • Speaker: Michael Fogus (t b), Clojure and Clojurescript contributor, co-author of The Joy of Clojure

Datalog is a pretty cool logic and query language that works with Datomic and Datalus. There's also Cascalog which is a map/reduce version for clojure. Bacwn adds negation to datalog. It looks a lot like sparql to me, but sadly that's directed at RDF, whereas datalog is pointed to more generic types of databases.

Roy

  • Language: Roy
  • Speaker: Brian McKenna (t b), programmer at Precogio, Roy creator

I would describe Roy as Haskell for JS. It has haskell style static typing which is pretty sweet. There's no type output in the compiled JS.  Sidenote: you can have haskell defer type errors until runtime.

Julia: A Fast, Dynamic Language for Technical Computing

  • Language: Julia
  • Speaker: Stefan Karpinski (t gh), Researcher at MIT, Julia co-creator

Julia is a fast, dynamic language for technical computing. Features include:

    • a unified type system (i.e. no int vs Integer like in Java)
    • efficient use of numerical arrays
    • parametric types
    • no inheritance from concrete types
    • operator overloading for everything
    • tries to avoid being built on c/fortran libraries
    • Uses type specialization by the compiler
    • fast
    • did I mention fast

Stefan did a demo wherein he created a parameterized type: ModInt{N} where N is a value parameter (e.g. 11), then implemented + and * in a few lines, and then created a random matrix of ModInt{11}, and raised that to 100,000, and it was instant. There was a chart of performance for other technical computing languages: fortran, R, python, matlab, etc. And we were all like, oh yeah Julia is pretty fast, comparable to fortran and much faster than the rest, and then he pointed out that the graph was logarithmic scale, and all our jaws dropped.

Rust

  • Language: Rust
  • Speaker: Dave Herman (t b), Programming Language Propeller Head at Mozilla

Much like how Google is making Go, Mozilla is creating their own systems language: Rust. They have a haiku:

a systems language pursuing the trifecta safe, concurrent, fast

They believe abstractions should not cost you unless necessary, e.g. if you write a method, and it can be inlined for better performance, they will do that.

They described it as the love child of C++ (for fast), Erlang (for concurrent) and Haskell/OCaml (for safe).

It has multiple types of pointers (and I thought 1 was bad enough): Stack Based, Memory managed/shared, one-owner/unique. The later is necessary for sharing data between different tasks (threads). Each task has its own stack and its own heap (perfect for different tabs in a browser). They have parametric types, that are implemented via code duplication like c++. There's an ARC container that requires deeply immutable type, but there needs to be locking on the reference counter.

Further resources: smallcultfollowing.com/babystepspcwalton.github.com

Grace: An Open-Source Educational OO Language

  • Language: Grace
  • Speaker: Michael Homer (gh b), PhD student at the Victoria University of Wellington

Grace (unrelated to our intern) is an open source OO language for education, ideally CS1, CS2 and second year students. It doesn't have any incantations, like how in the first class using java you have to say: "Don't worry about that public static void main" part, because you don't really want to explain scoping and static vs. instance. "Things that are more important come closer to the start of the line" So grace does: var previous:Number := 3.

It allows multipart method names, which I thought was pretty cool: 5.between(3)and(8)

The control structures are just multipart methods, so you can write your own if or while.

There's no null, which was the main question, as to why that was left out, and basically the response was that null causes headaches for new students and experienced programmers alike. This made me wonder why every object is optionally null in languages like Java or C#. It seems pretty rare that I want to return or deal with null, why not make nullable be explicit, like with C# structs.

Elixer: Modern Programming for the Erlang VM

  • Language: Elixir
  • Speaker: Jose Valim (t gh), Lead Developer at PlataformaTec, member of the Ruby on Rails Team, author of Crafting Rails Applications

Erlang VM is groovy and super concurrent, so Elixir was built on top of it, adding nice macros and protocol things that are not in erlang.

Visi: Cultured and Distributed

  • Language: Visi
  • Speaker: David Pollack (t b), Telegr.am CEO, Visi and Lift contributor, author of Beginning Scala

David wrote the Mesa and Integer spreadsheet apps. Spreadsheets are for non-programmers, and visi is supposed to be like that. All the code is markdown, and the visi github pages are actually the tests for visi (supposedly). It's all very light-table-y, where you can just say that something is a source (e.g. x or y or "revenue") and sinks (e.g. "profit") then you have a form on the left with all your sources, and list on your right with all the sinks.

1 Comment