Jenny Finkel opened this year’s Strange Loop with a cool talk on how their news app Prismatic uses machine learning to suggest stories to users, and discussed some of the pitfalls they’ve run into. Favorite moment: when asked if they used any special data analysis tools, she replied, “emacs.”
Avi Bryant gave a fun and easy-to-follow explanation of commutative monoids and their relevance to aggregation software. Basically, this is the name for the property that makes it so easy/efficient to do distributed calculations of sums (each node can perform a local sum and send only that value over the wire, and these can be combined to get the correct total result); there are less obvious applications like tracking unique values and frequencies of values, which can all share some common infrastructure.
The use of atomic clocks and GPS in Google’s Spanner database system was explained by Sebastian Kanthak. Ideally, every computer would have access to an objective ‘true time’ value, but computer clocks always diverge from one another. Spanner tackles this problem by determining (through calculation and measurement) the worst-case rate of divergence for a server’s clock, which the server uses to keep track of its clock’s current amount of uncertainty (which increases at that rate between periodic synchronizations). Time values can then be recorded as a tuple of (earliest possible time, latest possible time), enabling effective reasoning about order of events. (When the clocks are synchronized, any servers whose clocks are found to be diverging more quickly than expected are flagged for repair.)
Chris Granger talked about some of the issues that make programming difficult and demoed a prototype for his “Aurora’ project. The demo involved interactively creating/editing some data structures and rendering a UI and graphs. At the end (if I heard correctly) he mentioned that similar techniques were used to build the prototype itself - I wish the presentation had focused on that. I’m convinced by his claim that there are some pervasive problems with the way development is currently done, and I’m excited by the current interest in finding better approaches, but his demo didn’t give me a sense of how the development, deployment, and maintenance of a nontrivial project could work.
Martin Odersky’s talk “The Trouble with Types” (spoiler: he still likes them) argued that a major source of the perceived complexity in a language like Scala is the number of combinations that can result from the several basic types of types. Even when the building blocks are simple, the ability to arbitrarily combine them leads to a large space of possibilities, which can be difficult to understand and correctly plan for. If you can project this space of types down into a more limited set facilitating the most important combinations, it will be more manageable. He detailed a planned simplification for Scala’s type system.
Out of everything at the conference, the idea I feel the most need to do follow-up research on is program synthesis. This wasn’t on my radar as a practical technique at all, so Leo Meyerovich’s discussion of it blew my mind.