Polyconf Experience Report
This year’s PolyConf is over and although it was my first time at this conference and I didn’t know too many people going in I had such a great time and learnt so much I’ll definitely be back in the near future.
Recording of the talks are slowly appearing on their YouTube channel, so keep an eye out the talks mentioned below.
The conference is hosted at the Adam Mickiewicz University in the heart of Poznan and the facility is very modern.
The weather was great and fortunately the auditorium was very well air conditioned and ventilated given the temperature (around 30 degrees Celsius for the entire duration of the conference)!
Coffee was served throughout, and although lunch wasn’t to my taste (maybe it’s my Asian palette) there were always fresh fruits and snacks around to keep you going.
Oh, and there was a conference party every night with plenty of local craft beer on offer
The format of the conference was very refreshing in that it has a single track and each of the talks is only 30 mins long. Having a single tracks means you no longer have to stress over deciding which talk to attend.
The workshops were followed by two and half days of 30-min talks with 10 mins of break in between. This format caused some logistic problems. Many speakers had to adapt their talks to fit into the shorter-than-usual slot and ended up taking the full 30 mins so Q&A had to take place during the allocated break time which pushed the subsequent talks back or cut the breaks short and caused attendees to come back late for the next session and so on.
True to its goal of being a conference dedicated to polyglot programming there were a lot of different languages on show. Whilst EmojiLisp might just be the funkiest language of the lot, my picks from the conference have to be:
- program synthesis with miniKanren
- Racket’s language extensibility
- Crystal’s performance
- generated functions in Julia
The highlight of the first day for me was definitely miniKanren.
I attended William Byrd’s miniKanren workshop and went through the process of designing and building a relational interpreter that supports a subset of Scheme in miniKanren.
What does ‘relational’ mean here?
It means taking code such as:
let f x y = x + y
and instead of seeing it as a function that takes input (x and y) and returns an output, you treat it as a relation between the values x, y and output.
Given this relation, you can deduce the value of a missing part if you know the values of the rest.
E.g. given x = 3, and output = 5, y must be 2
If more than one part of this relation is missing, then you can still deduce the value of the rest in terms of relations to each other.
E.g. given x = 3, then output = 3 + whatever value y takes
Now, if you have an interpreter that can evaluate your application code as a relation to its output when executed, what might you be able to do then?
Perhaps, you’d be able to synthesize the application code given some desired output value. For instance, you might be able to generate 99 programs that will output “I love you”.
Besides miniKanren there were also a couple of other good talks on day 1, I particularly liked Wojciech Ogrodowczyk’s Beyond Ruby talk where he used the Piraha people as example to demonstrate why it’s so important to be polyglot. It’s one of the angles I used in my Tour of Language Landscape talk at NDC Oslo too.
p.s. you can find all the code for William’s workshop and talk on miniKanren here.
Based on the numbers Erik showed and a couple of his benchmark tests (one of which was a simple Hello World web server), Crystal can be very performant whilst retaining much of Ruby’s syntax.
In fact, the syntax of Ruby and Crystal are so similar (which is by design) you can even compile and run Ruby code (e.g. by running crystal xyz.rb) using the Crystal compiler and get a free speedup! Of course, this only works if the Ruby code also happens to be valid Crystal code.
Crystal also has some modern language features such as type inference and macros too.
Whilst I had been vaguely aware of Racket as ‘another LISP’ I had no idea just how much extensibility you have at your fingertips via the #lang notation. Sam Tobin-Hochstadt’s talk did a great job in illustrating this using a number of examples:
You can introduce a gradual type system by extending the language using a library and the #lang notation. To give you an idea, here’s a screenshot from the official getting started guide:
Similarly, you can also turn Racket into a lazily evaluated language (like Haskell) using #lang lazy.
I saw a lot of impressive things at PolyConf but the ability to ‘hack’ the language in this way might have just topped the lot.
Just for fun (since EmojiLisp was introduced in an earlier lightening talk), Sam also showed how you can basically implement EmojiLisp in Racket with a few lines of code.
(on a side note, whilst not nearly as powerful as Racket in this regard, you can also do some really cool things with Elixir’s macro system. If you’re interested in Elixir, then you would want to watch this talk by Chris Mccord at NDC Oslo too)
Finally, here are some of the best tweet during the conference:
So that’s it folks, another conference down and another bunch of things added to my ever-growing todo list!
Next, I’ll be speaking at the Cambridge F# User Group on the 20th July to talk about how Gamesys is using F# to build backends for games played by millions of players every month. Feel free to join us if you are in the area.
You’ll next find me at a conference on September 12th, at the first ever Kats Conf in Dublin, organized by Andrea Magnorsky. Edwin Brady will be there to talk about dependent typing and Idris, and I’m expecting to see an exciting lineup of speakers being announced soon!