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?

Comments from CQL Readers

Paul Snively 09/26/2014

Hi Chris! You're right; my comment does go too far in a sense, I think, because it's missing some context. This is a big risk that Amanda and I always take in trying to capture the essence of many, many conversations we have and turn them into a presentation. When I said that, I was being quite literal and serious: I would prefer working in Ruby to working in C, C++, Java, or Go, and I think that's a perfectly sensible, rational position. But it somehow still sounded like I was denigrating Ruby, which was not my intention at all. The point was—is—that there are type systems not worth using… and some of them are pretty popular! Anyway, I'm HUGELY honored to make your list, as I'm sure Amanda is also. All the more so since you saw us online rather than in the room. Hopefully on some future occasion you'll be in the session and we can chat afterward (the single thing I feel most guilty about: running out of time for Q&A). Thanks again!


Chris Shaffer 09/29/2014

Hi Paul! Well, I'll start out by saying thanks for responding, and now I am honored that you've seen and responded to my post! As far as your comment regarding the languages goes, I took it as a bit of hyperbole (and probably should have mentioned that above too), but I think I'm beginning to understand how you could mean it literally. Reading your recent post about Strangeloop (for those curious:, I liked your comments regarding surprise as to the controversial statements in your presentation. I don't remember the statement regarding objective reality (sorry - I was probably still processing something that came before it!), but then I think philosophically speaking (without fully reviewing the arguments or considering it in depth) that I agree with the statement anyway. As to the statement regarding ethical SLA behaviors, I've now added "Types vs. Tests" to my list of sessions to watch, perhaps I'll see in there why you don't think that an appropriate set of tests couldn't "ethically" be used as an alternative to type systems (though given the choice between writing the "appropriate set of tests" and letting the compiler handle it for me I think I'd choose the compiler). Thanks again for reading my post, as well as for taking the time to put together and give the presentation in the first place (and Amanda too)!


Leave a Comment

Subscribe to Our Blog

Continue Exploring




Our Work Services Commerce Cloud Approach Culture Blog Careers Contact

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