Topics
Social
Subscribe

7 Talks From Strange Loop You Shouldn't Miss

7 Talks From Strange Loop You Shouldn't Miss

Last year I attended the Strangeloop conference in St. Louis. Not only did I learn a lot, but it was a ton of fun too. It was also interesting to think about the differences between this conference and Codemash.

There’s also quite a difference in focus. Codemash includes a lot more on Test Driven Development, process concerns, and interpreted and dynamically typed languages. Strangeloop focused more on functional languages, often statically typed, and distributed computing.

The focus at Strangeloop was beneficial though, since we should all get more comfortable with functional concepts and distributed computing as functional aspects are added to many imperative/object oriented languages. And of course distributed computing is becoming more important as the quantity of data available increases and processing the data and events requires more CPUs/machines.

Since all the sessions are available on YouTube (which is amazing, I wish Codemash would do that) I've included brief summaries of my favorite sessions that you should check out. 

Turning the Database inside out with Apache Samza, Martin Kleppmann.

This talk compared databases to global shared state (something that we’ve worked hard to get away from using inside of our applications) and then followed up with an alternative approach that can offer many of the same benefits of a standard database but in a different way. The approach is to use messages along with message processing to build up a similar view to the database. The messages could be directly compared to something like a transaction log in SQL, but if maintained, you could process those messages to obtain point in time snapshots of the data, or to build up many separate (potentially denormalized) views of the data. 

Keynote – Inside the Wolfram Language, Stephen Wolfram.

This was more of a sales pitch for the Wolfram language than anything else, but it was fun seeing him demo this product.  His basic premise is that the “pare down a language to the core and let all other functionality be a separate library” approach is wrong.

The Wolfram language has everything built in – It is crazy what this language can do in a single line.  The demo includes things like pulling pictures from the laptop camera, instantiating and training an image classifier, finding sub groups in a facebook social graph, deploying code, and getting code to connect to a deployed Wolfram application in Java (yes, those last two mean that there is a function call built into the language that allows you to deploy your code and another one that will give you code in another language to consume an API that you exposed via a deployment).

Included with the code is a significant amount of data (eg, dictionaries in several languages, full object models of movies/actors/artists/etc). I don’t agree with his fundamental approach as a general means of providing functionality (I think different people are going to need functionality that doesn’t need to be part of the core language), but it is impressive what you can do in a very small amount of code when you are working in such a system [where everything is included and as much as possible normalized].

In fact, they have a twitter account (@wolframtap) that will run code you send it and return the results to demonstrate that you can do pretty impressive things in fewer than 140 characters.

Jepsen II: Linearizable Boogaloo, Kyle Kingsbury.

This was a fun, full of energy talk about distributed systems and a few of the ways that they can fail. He talked a bit about the CAP theorem (Consistency, Availability, Partition Tolerance can’t all be guaranteed in a distributed system) and then pushed the idea that when designing a distributed system one should not ignore Partition Tolerance (pointing out that a thread or virtual machine going to sleep or a hardware failure constitute a network partition, all of which are very likely to happen at some point).

The Jepsen scripts that he’s written will take a distributed system and hammer it with data and test whether it works. It will give a linear display of why the system didn’t work when it doesn’t (which there are  some well-known projects that do fail).

Fast, Secure, and Safe: The web that can still be, Chris Morgan.

This session was an argument against the dynamic/interpreted web that we largely have now and in favor of using compiled languages with good type systems to help make a faster and more secure web. C# (which we often use here) falls into a middle area – it is compiled, but the type system and the fact that it runs on a virtual machine were points against it. I haven’t looked at Rust, but I’m very interested to check it out now. I’m also  interested in the idea that an appropriate type system can protect against code injection attacks (which he mentioned “Ur/Web” can do).

Keynote - Our Shared Joy of Programming, Carin Meier and Sam Aaron.

This was a very fun/uplifting way to finish the conference. Not very technical in nature, talking about staying healthy and remembering (and being able to explain to non-computer people) why we like to program so much.  Sam Aaron talked about a recent project “Sonic Pi” that lets kids experiment with programming through music on a Raspberry Pi (also runs on Mac).  They finished with a demo of live-coding music and dancing robots that probably wasn’t technologically speaking as impressive as it sounds but it was a blast to watch! Some search terms: Overtone (Play/write music via Clojure code), used by Meta-X (live-coding band), and the basis for Sonic Pi (bringing the same coding technique to the Raspberry Pi in an easy to operate/kid friendly way).

How to make error handling less error-prone, Daira Hopwood.

This talk reviewed several “bad” ways of handling errors (many of which are still used in standard frameworks/APIs) and why they are bad.  The “good” error handling approach is Exceptions, and she recommended reading Goodenough’s 1975 paper that describes the functionality that we now have in many languages (though apparently some aspects aren’t commonly implemented). Unfortunately she ran out of time before she finished. At the end of the talk she started to get into the idea of marking code in terms of guaranteed error handling state – eg, a block of code will maintain certain invariants, act atomically (all succeed or all fail), or guarantee no exceptions, and then when you compose code from those methods it would be easier to reason about the composition (I assume at this point the task could be handed off to the compiler).

Type Systems - The Good, Bad, and Ugly, Paul Snively and Amanda Laucher.

I wasn’t able to go to this one in person, but I’ve watched it on youtube since then. This talk really impressed into me the need to investigate type systems of various languages. One quote from the session was “If the only type systems I knew were C, C++, Java, or Go’s, I’d be a Ruby programmer too.” That’s probably going a bit far, but there is a lot that I don’t know/understand about type systems that I want to learn.

While these are my top picks, there are plenty more to watch, so don't limit yourself! I'm still going through the ones I couldn't make it to in person. 

Are you attending Strangeloop this year? Which talks are you most looking forward to?

Continue Exploring

Approach

Culture

Careers

Our Work Services Commerce Cloud Approach Culture Blog Careers Contact

3344 Grand Ridge Drive NE
Grand Rapids, MI 49525
616 365 1000