The gentle breeze brushed my face and the mild sunshine warmed an otherwise chilly morning. I was standing in front of a large building that can only be described as unique: a series of metal plates jutting out at odd angles, whose dull resplendence cast an instant impression. It was the Ray and Maria Stata Centre, a towering monolith and the venue for an event that people from all over the world came to attend and participate in. I was in town for the third edition of JuliaCon
, the annual Julia Conference at MIT.
On the eve of JuliaCon, a series of workshops were organised on some important areas people use Julia for. I was conducting the Parallel Computing workshop
along with some other members of the JuliaLab
. The key idea in our workshop was to show users the many different ways of writing and executing parallel code in Julia. I was talking about easy GPU computing using my package called ArrayFire and achieving acceleration using Julia’s multi-threading.
Day 1 started off with the first keynote speaker – Guy Steele, a stalwart in the software industry and an expert in programming language design. He spoke
about his adventures designing Fortress, a language that was intended to be good at mathematical programming. He went through the key design principles and tradeoffs: from the type hierarchy, to their model for parallelism (automatic work-stealing), and interesting choices (such as non-transitive operator precedence). My colleague Keno Fischer was up next with a tour
of the new Julia Debugger: Gallium! Gallium was quite breathtaking in its complexity and versatility, so much so that Keno himself uses it to debug code in C and C++! A powerful debugger becomes even better with GUI-integration, which Mike Innes very usefully pitched in
with during his demo of Juno-Gallium integration. Stepping, printing and breakpoints promised a powerful package development experience.
The next session was all about data science. Simon Byrne spoke
about the data science ecosystem in Julia and future plans. He touched on the famous problem
with DataFrames, and then laid out a roadmap for the ecosystem. The rest of the session featured an interesting demo in music processing
, while Arch Robison showed
us how to use Julia as a code generator.
The evening had two sessions in parallel at different rooms. This is a recurrent feature of JuliaCon, and it’s always hard to decide which session to attend. This time, I chose to attend the sessions on automatic differentation
. I didn’t want to miss the talk
on iterative methods for sparse linear systems. Performance of different kinds of techniques and approaches were compared and evaluated against one another, which made for a compelling presentation, which I really enjoyed.
The evening session featured Jeffrey Sarnoff, one of the sponsors of JuliaCon 2016. Mr. Sarnoff had some very interesting thoughts
on extended precision floating point numbers. And so ended the first day at JuliaCon. Now it was time to head to the JuliaHouse! The JuliaHouse was an AirBnb that a bunch of Julia contributors rented out. They had a yard and a barbecue and it was the ideal place for people to go relax, unwind and network with the other Julia folks. People chilled there till the wee hours of the morning, and somehow made it on time for the next day’s session.
The second day started with a keynote speech
by Professor Tim Holy, a prolific contributor to the Julia language and ecosystem. He spoke about the state of arrays in Julia and showed us a few of his ideas for iterators. I saw that Professor Holy is widely admired in the entire Julia community due to his involvement in various packages and the key issues on the language. I noticed that he asked some pretty neat insightful questions at various earlier sessions too. Stefan was up next with his super-important Julia 1.0 talk
. It was quite a comprehensive list of things that needed to be done before Julia would be 1.0 ready and he touched on a variety of areas such as the compiler, the type system, the runtime, multi-threading, strings and so on.
The next session saw a team from UC Berkeley show off their autonomous racing car
that uses some optimization packages (JuMP and Ipopt in particular) to solve real-time optimization problems. Julia was running on an ARM chip with Ubuntu 14.04 installed. Julia can also run on the Raspberry Pi, and my colleague Avik took some time to show off
a cool Minecraft demo running on the Pi. The talk after that was about JuliaBox. Nishanth, another colleague of mine, has been hard at work porting JuliaBox to Google Cloud from AWS, and he spoke
about his exciting plans for JuliaBox.
Post lunch, I had to choose again between parallel sessions, but I couldn’t quite resist the session with stochastic PDEs and Finite Elements. Kristoffer Carlsson reviewed the state of FEM in Julia
, talking about the packages and ecosystem for every FEM step from assembly to the conjugate gradient. The next talk
was given by a professor at TU Vienna whose group conducts research on nano-biosensors, and the group uses Julia to solve the stochastic PDEs that come up when trying to model noise and fluctuations. The next talk
on astrodynamics was very interesting in that it gave me an insight into the kinds of computational challenges faced by scientists in the field. There were also some interesting demos which I enjoyed, particularly the one where we modelled and visualized a target orbit, which superimposed upon a visual of the earth in space.
In the afternoon, after much consideration, I went to the session that featured statistical modelling and least squares. The first talk on sparse least squares optimization
problems gave me a flavor of the kinds of models and problems economists need to solve, and how the Julia ecosystem helps them. The next talk
on computational neuroscience focussed on dealing with tens of terabytes of brain data coming from both animals and human surgery patients. I had a very interesting discussion with John earlier about his work, and I was able to get a keen sense of how why the package he was talking about (VinDsl.jl) was important for his work. And so ended Day 2 at JuliaCon, a highly educational day for me personally, with insights into astrodynamics, finite elements and computational neuroscience.
I would contest that one of the best ways to begin your day is to listen to a speech by a Nobel Laureate. It was quite a surreal experience
listening to Professor Tom Sargent, and to see him excited by Julia. He gave us a flavor of macroeconomics research and introduced dynamic programming squared problems that were “a walking advertisement for Julia”. As a case in point, the next session
on DSGE models in Julia highlighted the benefits Julia can bring to macroeconomics research and analysis.
The next session had a bunch of Julia Summer of Code (JSOC) students present their projects. Some couldn’t make it to the conference so they presented their work through Google Hangouts
or through pre-recorded video
. Unfortunately, I couldn’t catch all of them because I wanted to catch my colleague Jameson’s Machine Code talk
which was in another room. The material he spoke about was very interesting, and got me thinking about the Julia compiler. I also had a very enlightening discussion with him later about the Julia parser.
It turned out that in the afternoon, I was crunched for time. I was helping Shashi plug ArrayFire
for his talk that was due in a couple of hours, while also working on my own ArrayFire notebooks for late that evening. But we managed to pull through in time. So the afternoon session had Shashi presenting
Dagger, his out-of-core framework, followed by a tour
from the IntelLabs team. I have been following ParallelAccelerator for a while, and I’m excited by how certain aspects of it (such as automatic elimination of bounds checking) can be incorporated into Base Julia.
The evening session showed people how they can accelerate their code in Julia. The speaker before me covered vectorization with Yeppp
before I covered
GPU acceleration with ArrayFire. It was quite overwhelming to be speaking in front of a bunch of experts, but I think I did okay. But I did finish 5 minutes faster than my allotted time. As it turned out, both parallel sessions actually ended up concluding a few minutes early.
Finally, Andreas came up to the podium for the concluding remarks and closed off a very important JuliaCon for me personally. I was able to appreciate the various kinds of people involved in the Julia community: some who worked on the core language to some who worked on their own packages as part of their research; some who worked on Julia part-time, to some (like myself) who worked full-time; the relatively uninitiated JSOC students to experienced old-timers in the community. One thing tied them all together though: a quite thorough appreciation of a new language whose flexibility and power enabled people to solve important problems, whose community’s openness and sense of democracy welcomed more smart people, and the idea that a group of individuals on different time zones and from different walks of life can drive a revolution in scientific computing.