I attended the very first RustConf in Portland this September, as well as the annual Strange Loop conference in St. Louis, Missouri. My friend Jeena (with whom I’m working on Servo this summer) and I were able to go thanks to the generous opportunity grants given to us by both conferences. :)

These were my first technical programming-centric conferences, so it was interesting to be around so many people at once who are super into programming. Definitely a different vibe from my Intro to Programming class in undergrad.

RustConf

RustConf had a really nice selection of talks, and it is hard to choose a favorite!

Probably the talk from which I learned the most is Without Boats’s “Using Generics Effectively”.

Prior to this talk, I knew that traits were a way to define behavior that multiple structs can implement. Without Boats argued that people should use traits more (e.g. in place of using logic switches in a main function) and gave an example of how using generic traits in the notty project led to much cleaner code. And I liked the point about how the use of traits can provide an additional level of abstraction (“abstraction is about separation of concerns”), which is something I hadn’t considered before. There was also a shout-out to Nick Cameron’s Rust Design Patterns repo, which I found useful.

Until the video gets posted online, Zack Davis has a good summary of the talk and the RustConf experience as a whole. :)

Some things to brag about: RustConf socks and lots of stickers! And I got a copy of Julia Evans’s awesome zine on systems programming. I’ve since used strace to figure out why Skype is bugging out on Ubuntu and failing to close upon exit…

And now a word cloud of some of the concepts and projects I realized I need to learn about after attending RustConf:

Strange Loop

In St. Louis, Missouri I went to Papers We Love during the pre-conference day, as well two full days of Strange Loop talks. I think what was cool about the St. Louis conferences was the breadth of technical topics that were covered.

For instance, at PWLConf I really enjoyed the talk about Randomized Gossip Methods. It turns out that if you want to efficiently and randomly spread gossip in a network, certain algorithms are suited for spreading information when only a few nodes know the “gossip” (and at some point you switch over to another algorithm). Cool. :) It was a bit unnerving – but really cool – to learn about Automatic Patch Generation. It seems like automated debugging (which reminds me a lot of biological evolution) might actually be quite reasonable for test-driven software.

A lot of people at Strange Loop were interested in Rust. When people would hear that I had a bioinformatics background they would ask “what’s bioinformatics?”, but they would always be excited to hear I’m learning Rust for the summer.

Another thing that happened is I would overhear tidbits of information or learn something in a conversation, and then later that information would become useful in helping me understand some other concept. For example:

Q: What is the Lambda Ladies group I keep hearing about? A: It’s a functional programming group! Q: Why is it called Lambda Ladies? A: Because functional progamming is based off of lambda calculus! I later attended the Unlimited Register Machines talk, which discussed how 3 equations can be combined together in a register machine (related to Turing machines) to calculate or simulate pretty much anything. Then I learned from our coach Nick that OOP is based off of Turing machines, while functional programming is based off of lambda calculus. But apparently the two have been proven to be equivalent to each other. That’s really cool! And now I want to create my own machine…

We also popped in briefly to the Haskell coding dojo, which is a really unique mob-programming format where Haskell newbies write programs together using a fast-paced trial-and-error method. One thing I learned that isn’t Haskell-specific but has stayed with me since is to “use a function first and define it later”. Hopefully this motto will help me avoid cycles of indeterminism from now on.

There were a lot of cool talks during the two days of Strange Loop, and because there were always 4 or 5 talks going at once, I only made it to a fraction of them. Luckily they are all posted online!

I really enjoyed Martin Kleppmann and Diana Vasile’s talk about how End-to-end encryption works.

It was both funny and informative. It seems that encryption algorithms (or rather, their designers) have had to become quite clever in order to send messages that cannot be maliciously decrypted by third-parties. Apparently, one of the most popular encryption techniques, RSA, works because it is very difficult to factorize the product of two large prime numbers. And related, it is very difficult to calculate the original m = 65 after the following encryption (i.e. without the knowledge of an associated private key), even if you know the values of n = 3233 and e = 17:

encrypted message = unencrypted message m ^ e mod n = 65^17 mod 3233 = 2790

Example taken from wikipedia. That’s cool!!!

Now for the Strange Loop word cloud of a few of the things I want to learn more about:

This brings my number of new t-shirts to 3.

Conclusion

I learned a lot and met a lot of smart and friendly people in the past two weeks!

I appreciated the attention paid to making minorities and newcomers feel welcome through Code of Conducts and opportunity grants, among other efforts. Still, the > 4:1 ratio of men to women was definitely noticeable! I think that in order for myself to really register the imbalanced gender ratio in tech, I had to see it for myself. (On the plus side, the bathroom lines have been a lot shorter for me than usual…)

Overall I think I now have a better sense of the current state of programming culture, and I learned about gaps in my knowledge and things I should work on, both intellectually and socially. And I found a bunch of new topics which interest me. Now if only I had all the time in the world to become an expert in everything.