I just finished an incredible (and exhausting) week at LambdaConf in Boulder, Colorado. I can say with confidence that it's the best programming conference I've attended, and I'm anxious to be able to attend it again in the future.
I wouldn't call myself terribly experienced - 28 years old and only 4 years out of college - but I have developed a professional comfort in a few areas:
- Interacting with F# developers
- Interacting with C# developers
- Booth duty at Microsoft conferences
- Being an "important person" at F# conferences because of my job
- Talking about functional programming through the lens of F#
- Being the person with the answers to questions
- Having moderate to deep knowledge on the topics presented at conferences I attend
None of these were true at LambdaConf. Instead...
- Only three other attendees knew me, and the only people I had previously spoken to in-person were those three attendees
- I represented a language (F#) that has historically not had much representation at LambdaConf, and has never even been used by a large majority of attendees
- I had zero experience with many advanced topics being presented, some of which I attended
...and I couldn't be happier with how it went.
LambdaConf is the first time I legitimately flunked out of something due to simply being unable to keep up.
Alexander Konovalov and Emily Pillmore gave a 7 hour session entitled Isomorphic Reasoning: Counting with Types. I didn't even make it halfway before giving up. The content was well-presented, but I was simply incapable of understanding things after a certain point. Sounds like a failure, yes? Wrong!
In only 2.5 hours, my entire mind was warped as concepts I was familiar with - booleans, integers, products, coproducts, algebraic data types, and functions - were beautifully transformed into mathematical expressions. Relationships between different forms of types were derived and a framework for reasoning about them emerged in turn. I learned that many of the properties about constructs I use that I had simply found intuitive had a real, mathematical backing. Thanks to Alex and Emily, I now feel like I have a deeper understanding of how things like exhaustive pattern matching actually work, rather than taking something at face value as "intuitive" and "logical". There's a beauty to this stuff that I can now appreciate.
What's funny is that what I learned is only at the surface level for this stuff. There is so much more to learn, and I'm planning on getting to the point where I could take this course again and successfully complete it. All it took was getting thoroughly kicked in the ass by two brilliant people!
I met and spoke with many new people at LambdaConf, some of whom I was lucky to spend a lot of time with.
I got to spend hours with Michael Snoyman, Chris Allen, and Adam McCullough learning about the Haskell ecosystem and the kinds of challenges people encounter there. I learned about Stack and Cabal and why some people value one over the other. I learned why Rust is an attractive language to some Haskellers, and some of the approaches you might take to solving problems in Rust and contrasting that with Haskell. I learned that within the Haskell community, there are quite diverse philosophies on how to consider the different axes of type safety, composition, tools, and language evolution.
I learned about Haskell and Scala tooling from Cary Robbins and the technical and interpersonal struggles that underpin both ecosystems. We talked at length about topics ranging from overall technical philosophies to minute details about how tooling affects compiler design and how there can often never be a truly correct approach to solving a problem in programming tools.
I got to spend a late afternoon with Cary Robbins, Nihil Shah, Tyianyu Pu, Ryan Delucci, Michael Sloan, and others as a passive participant in conversations around how to handle IO in different circumstances. I learned about why Scala's Future isn't an idea abstraction, and how the ZIO library addresses entire classes of problems introduced by using Futures in Scala. I learned about the benefits and drawbacks of using ReaderT and Arrows in varying contexts when writing Haskell. I learned more about the Haskell community that evening over dinner, and ended the night discussing approaches to using machine learning to augment programming language tooling.
LambdaConf is the first conference I've attended that had an entire host of official extracurricular activities:
- Workouts guided by John De Goes
- Tea tasting
- Cooking competition
- Hiking
- Coffee tasting
- Pub outings
- Hackathons
And this is of course not counting any unofficial activities. I couldn't attend everything, but I've made an effort to go to as many activities as I could to experience wonderful parts of Boulder, CO with the some of the same brilliant people I spent my previous days with.
It's been deeply satisfying and refreshing to get my mind blown, get obliterated by a full-body workout, and then have some delicious tea in a tea house. Best conference ever!
Something impressive about LambdaConf 2019 is how few people made the magic happen. I have immense respect for Courtney De Goes, who basically ran the show. How she managed to find the time to also talk to a dork like me while keeping everything running smoothly is beyond me. The high quality of the food, the agenda, organization of events, and the welcoming and inclusive environment was clearly the work of professionals; yet this was no corporate event. The community feel was everywhere, and it's these kinds of things that make me eager to return.
I highly recommend attending LambdaConf. I know I'll be seeking to return. And perhaps I'll be able to spread some more F# love, too. In the meantime, I've got The Book of Monads to read and 30 pages of notes to review!