I spent some of last week at Strange Loop. I met lots of new curious, friendly, wonderful people, gave a talk that people really liked, played board games with friends, and generally had a great time.
It was also kind of a big deal for me personally! A year and a half ago I gave my first lightning talk at a meetup, and was super scared. I’ve heard a lot about how great of a conference Strange Loop was, and I really wouldn’t have anticipated then that
- I’d get to go
- they’d accept a talk I submitted (“You can be a kernel hacker!”)
- the room would be packed
- people would say things like “that was my favorite talk of the conference”
I always imagine cool developer conferences like Strange Loop as being full of wizard developers who know everything about programming. I was worried that my talk would be too entry-level (I explain what a kernel is / what a system call is from the ground up, for instance).
It turned out tons of people there didn’t know a lot about systems programming / how kernels work, and my choice to make the talk accessible made a lot of people happy. So far I’ve given a bunch of talks and I’ve never regretted trying to make it easy to follow for as many people as possible.
I collected some of the comments from Twitter to keep me happy on sad days. (also: super useful for convincing people they should have me speak when submitting future talk proposals!)
talks to watch
A few wonderful talks that I think are worth watching:
- Concurrency Options on the JVM by Jessica Kerr was a wonderful overview of concurrency models in various JVM languages (Akka, core.async, futures, …), what tradeoffs they have, and how to think about them. Every time I’ve seen her speak I’ve been impressed.
- How Julia Goes Fast by Leah Hanson was a solid introduction to the choices the Julia language has made in order to perform well for numerical computations, and how to write your own fast Julia programs. For some reason the video isn’t up yet.
- Benchmarking: You’re Doing It Wrong by Aysylu Greenberg was a wonderful talk explaining common errors people make when benchmarking, and laying out strategies for writing better benchmarks. The next time I need to make a benchmark I will absolutely watch this talk.
- Jepsen II: Linearizable Boogaloo by Kyle Kingsbury was wonderful, as all of his talks are. The room was packed, and he struck a great balance between discussing serious problems he’d found in distributed systems (in this case RabbitMQ and Elastic Search), and acknowledging that the developers who work on large distributed systems are solving a really hard problem. The message wasn’t that people building distributed systems are doing bad work, but that we need to be honest about the tradeoffs that the systems we build are making, and document known problems. For instance, Elastic Search is a great search engine, but you should absolutely not use it as a primary datastore because it can lose your data.
Talks I heard good things about, and am planning to watch the videos of later:
- Art.js: Transfigure data to Create 21st Century Art by Sarah Palermo
- The Sociology of Programming Languages by Leo Meyerovich (a talk about programming language that involves an actual study, with data, of how people choose programming languages! How can it be!)
- I have hard nothing but rave reviews of Practical Fractals in Space by Michelle Brush
- Idris: Practical Dependent Types with Practical Examples by Brian McKenna was described to me as “types from space”. I’m not a huge type theory nerd, but this sounded like a fun talk to watch.
- Spreadsheets for developers by Felienne Hermans is by someone who has a PhD in spreadsheets. How cool is that? I have every regret about not watching this talk.
- Towards “annex”, a Fact Based Dependency System by Mark Hibberd
- Simulation Testing by Michael Nygard
Strange Loop tried really hard to be more inclusive this year. Bridget Hillyer wrote a great wrap up post. The most striking thing to me was this:
[We engaged Ashe Dryden to help us come up with a plan]. I took that plan and made a list of the steps included. I assumed Alex Miller and I would prioritize them and decide what we could actually pull off. Alex said we should do all of them. There were 58 items on that list. Plus, Alex did many things beyond what was on that list to make the conference more accessible and comfortable for all involved.
I love the idea of taking a huge list of ideas to make a conference more inclusive and just doing every single one. There were tons of women at the conference, and a lot of my favorite talks were by women.
I’ve become pretty used to spaces with lots of women developers in them after Hacker School, so I didn’t find the number of women super surprising (of course there are tons of awesome women who write code! that’s how it always is). 12% doesn’t even feel like a lot to me! But it was pretty great, and I got to meet a bunch of old and new friends.
One small thing that I saw at Strange Loop that I didn’t like was a couple of talks making the following argument:
- languages with static type systems prevent a class of errors that dynamic type systems don’t
- therefore those languages are safer
- therefore if you’re writing mission critical systems, you should use static typing
This class of argument really bothers me, because it doesn’t really hold up in court by itself. I love using static type checking, and I would love to see evidence that statically typed programs actually have less bugs.
But this argument by itself isn’t that great. Strange Loop is a conference where we have a really unique combination of academics and developers with lots of industry experience. We could talk about this in a more nuanced way!
- are there studies with evidence that static type checking reduces the number of bugs?
- what about the claim that dynamic languages are faster to develop in? Do we have any evidence for that?
Or I’d love to see some analysis of case studies about organization that have made a big switch (like Twitter’s switch to Scala, for instance), by someone without an agenda to push (like “wow Scala is great!“).
It basically seemed like there were talks by people who really liked static languages, and talks by people who really liked dynamic languages, and they were just talking past each other. I didn’t learn anything new from these talks.
I’d like to go back next year and see better arguments. See you next year, Strange Loop! <3