Strange Loop 2016

TBA

TBA

TBA

TBA

Sifting through big data can provide fantastic insights into customer behaviour. However, besides map reduce and rigorous scientific methodology, there can often be interesting insights gleaned from the outliers. Zooming into small data can reveal either bugs in your big data scope or oddball user behaviour. Both of these can be nuggets of gold. From the Iraq War Logs to Fifa Files, Nicola Hughes, an investigative data journalist turned developer will go through the data principles learned from digging deeper into data. How to isolate human behaviour. Why to be distrustful of your data. And how to interrogate your data like an investigative journalist. Ultimately, deciphering a bug from a story.

Managing the consistency of interactive visualizations in the face of inherent asynchrony and reordering of events in modern data visualizations is challenging. This talk will go over a new view (query) based model for interactive visualization and show how database transaction techniques could apply to consistency for visualization scenarios, and present a set of declarative policies to maintain visualization consistency. We will a see a demo of this DSL in action.

Conceptualization and understanding are prerequisites for changing software. But they are harder to achieve as software becomes more complex and expands in scope. We have many tools for writing software, but few at all for reading and understanding it. What if there were tools that helped us conceptualize systems so that we could change them with greater confidence? What would they look like and how would we use them. I will describe a new tool that helps developers rapidly build understanding of new software systems by generating an Idealized Commit Log: a simplified step-by-step deconstruction of a working software system. I will explain how the tool works by touching upon a diverse set of topics including type analysis, code coverage tools, AST transformations and a much-ignored topic of academic computer science pioneered nearly forty years ago called program slicing. Finally, I will apply the idealized commit log technique to explain the inner workings of a number of ostensibly complex real-world software packages to demonstrate its power and simplicity.

For any service, the frontend is the services which depend on it, and the backend is the services it depends upon. In a many-layered service-oriented system, the frontend server is the outermost layer, responsible for handling requests from the outside world. Typically, a frontend server is responsible for universal behavior, including authentication, rate limiting, and traffic prioritization. The exact behavior will vary from company from company, and so most large software organizations will write one from scratch; Google has "gws", and Twitter has "tfe". Recently, Fitbit built its own. Such a server has to be fast, stable, scalable, extensible, and easy to monitor. However, the entire code base is only 3000 lines of code, making it an ideal platform for exploring the low-level engineering decisions that enable these properties, and the tradeoffs between them. This talk will explore the implementation of Fitbit's frontend server, covering topics ranging from queueing theory and software design to GC tuning and the Netty library. It is meant to be a deeply practical discussion of topics which are normally only discussed in the abstract.

Project Jigsaw will bring modularity to the Java platform; something that will enable better security, performance and flexibility for deployment of applications. This talk will look at the fundamentals of how modularity in Java will work. Developers will need to understand that these changes go significantly further than just separating the standard class libraries into a number of discrete units. This talk will explain the impact project Jigsaw will have on developers in terms of building their applications, as well as helping them to understand how things like encapsulation of private APIs, which have up until now been visible, will change in JDK 9.

There are lots of programming languages out there, but very few like Modelica. Modelica is a standardized language for describing the behavior of physical and cyber-physical systems. It incorporates mathematical constructs and physical interactions directly into the language and it can be used to create graphical, component-oriented models of complex physical systems. Unbeknownst to most software developers, Modelica is used by a wide range of big name industrial companies (e.g., Ford, United Technologies, BMW, Airbus) to simulate a host of real world devices and systems. This talk will cover how the mathematical and physical information described in Modelica is transformed into a running simulation of that physical system. There are a number of fascinating algorithms that are needed to transform the hybrid differential-algebraic equations extracted from a Modelica model into imperative simulation code. The compilation is completely different from a typical programming language. Attendees may recognize some similarities to functional reactive programming (FRP) but extended to include continuous behavior.

This is a talk about language design. It is also a talk about language implementation, and how the two go hand in hand. We've spent the past 5 years building Cypher for Neo4j, and have now opened it up for other vendors as well. This is the story of what we learned along the way so far. This is a talk for anyone who is interested in learning about the things that are important to consider when designing a language for wide use. We set out to build a language that was specialised while being expressive, a language where simple things are easy, and complex things possible. We desired a language that is easy to learn, with a straight path to mastery. We wanted a high level declarative language for which we could write a high performance implementation. We knew that we would make mistakes and needed a way to correct those, our language needed to be able to evolve while being reliable. We have not been very scientific about our process, but have still learned a lot along the way. In this talk we will share those learnings with you, so that you too can learn from our successes and mistakes. This is not a story from an ivory tower, but a story about moving fast and breaking things. We never intended to build a language, but reluctantly found ourselves there anyway. With a small team and no budget we still produced something that a lot of people find very useful. We built something we are proud enough about to want to share the story of with the world.

Graph reducing interpreters combined with compilation to combinators creates a "virtual machine" compilation target for pure lazy functional programs that is extremely concise, simple in its semantics, and naturally parallelizable. In their simple forms these techniques are a useful introduction to compiling and interpeting functional languages. In much more sophisticated forms, they illustrate how large-scale compilers are implemented in used in languages like Idris. We'll walk through the process of compiling programs in the lambda calculus to pure combinators and a simple implementation of the most straightforward graph reduction algorithm. With that context, we'll look at the history of graph reduction, from a surge of interest and excitement in the 80s and 90s to serious reservations in the 2000s. We'll look at concrete examples of combinator compilation and graph reduction, and compare with alternative techniques in Haskell's Spineless Tagless G-Machine.

You might think of the Linux kernel as something that only kernel developers need to know about. Not so! It turns out that understanding some basics about kernels and systems programming makes you a better developer, and you can use this knowledge when debugging your normal everyday programs. Everything in this talk applies to every program, in every programming language. What could be better?

You've heard of Elm and it sounds super cool, but you can't rewrite from scratch and you don't want to give up the innovation of the React community! What if you could get Elm's benefits one file at a time while still utilizing your existing or 3rd party React components? What if that alternative also supported hot reloading, component styling, and smart editor plugins? What if it was simultaneously a simpler and more powerful language, letting you easily drop into familiar JavaScript while also supporting crazy powerful abstraction and typing features?? Welcome to PureScript (& Pux)!

Cluster computing frameworks such as Hadoop or Spark are tremendously beneficial in processing and deriving insights from data. However, long query latencies make these frameworks sub-optimal choices to power interactive applications. Organizations frequently rely on dedicated query layers, such as relational databases and key/value stores, for faster query latencies, but these technologies suffer many drawbacks for analytic use cases. In this session, we discuss using Druid for analytics, and why the architecture is well suited to power analytic applications. User facing applications are replacing traditional reporting interfaces as the preferred means for organizations to derive value from their datasets. In order to provide an interactive user experience, user interactions with analytic applications must complete in an order of milliseconds. To meet these needs, organizations often struggle with selecting a proper serving layer. Many serving layers are selected because of their general popularity, without understanding the possible architecture limitations. Druid is an analytics data store designed for analytic (OLAP) queries on event data. It draws inspiration from Google's Dremel, Google's PowerDrill, and search infrastructure. Many large technology companies are switching to Druid for analytics, and we will cover why the technology is a good fit for its intended use cases.

Enforcing the myriad of policies surrounding security, availability, cost, and other business requirements of new services in a distributed operating environment is not for the faint of heart. In this talk, Susan will demonstrate how to write a type provider in Idris which will read in VPC and subnet resource metadata from AWS and build a small library of functions that can enforce security, and availability policies for distributed systems deployments.

In the early 4th century, the Roman emperors Diocletian and Constantine looked around their empire, and realized that they had troubles. The crisis of the third century had left the empire broke, with the internal trade network badly disrupted and the currency devalued. With little money to pay troops, and the neighboring people having learned many of the Roman army's tricks, the empire faced a problem: How do you protect an empire with borders as long as the Empire's with fewer and less effective troops? The answer is interesting, and even more so when you consider how similar this problem is to that of network defense. When it comes to protecting our networks, we are outnumbered, and any technical superiority we may have had is dwindling. Further, while cybersecurity and cyberdefense are hot topics, their popularity is not being matched by an increase in staffing. So, like the Roman Empire, we must figure out how to protect our networks against a well-equipped enemy across a long attack surface using less staff. In this talk, I'll explain the history and show how we can apply some of the lessons learned: how we can apply the Roman's new, reactive style to better protect our networks, how we can design our systems to better survive in our new environment, and how we can start learning to use the fact that trust is not an all-or-nothing property. I'll even point out one lesson we've overlearned, and why you should definitely start forgetting the Battle of Thermopylae.

Since the 1970's, data analysis in high energy physics has revolved around the histogram: an array of integers approximating a distribution. Fortran codes drawing ASCII-art plots bear a strong resemblance to the analysis scripts that discovered the Higgs boson: imperative for-loops filling histogram objects. If this sounds cumbersome, it is. Explicit for-loops must be manually edited to add concurrency. However, the histogram concept itself is powerful: many data visualizations can be constructed by cleverly filling suites of related histograms, adding them, subtracting them, and dividing them bin by bin. Today, high-energy physics analysis is colliding with tools from the Big Data community. In my work with physicists adopting Apache Spark, I've found that histograms can benefit from a functional style, accepting fill rules as lambda functions, and they can be subdivided into more fundamental units. In fact, all the tricks for building complex data visualizations with histograms can be formalized as a grammar of "aggregator monoids." These aggregators are associative for easy concurrency and simple enough to implement in many languages. In this talk, I'll show you how to use Histogrammar, a lightweight, cross-language suite of histogramming primitives. Examples will include cluster-wide histogramming in Spark and tapping intermediate values in a GPU computation. It is my belief that the Big Data community can learn as much from physicists as physicists are from Big Data.

Where does the rain go once it hits the ground? Some of it soaks into the ground, and some of it evaporates. The rest flows into creeks, streams, lakes, and rivers, eventually making its way to an ocean. The route that this water takes is determined by thousands of regions called watersheds. Creating an interactive visualization showing how these regions connect to each other includes finding and reformatting some public data, some directed acyclic graph algorithm coding, reducing the size of the data set to something that can quickly be served in a web page, and some challenging graphics performance issues associated with the display of nearly 100,000 polygons in your browser. This talk will demonstrate and describe the architecture of a fun open source JavaScript web app that combines all these things to let you get an instant view of the areas areas both upstream and downstream from any location by simply pointing with the mouse.

This talk looks beyond origami as a childhood pastime and an art form and instead, explores origami as a source of many interesting mathematical problems, including one called the fold-and-cut problem. The fold and cut theorem states that it is possible, given a piece of paper and any polygonal shape, to find a series of folds of that paper such that the given shape can be generated with a single cut. This talk explores two proofs of the theorem and a Ruby implementation of a solver that determines the correct series of folds given any input polygon. There will be a live demo of the program and paper cutting!

Large-scale private user data theft has become a common occurrence. A huge factor in these privacy breaches we hear so much about is that developers specify and enforce data security policies by strewing checks throughout their application code. Overlooking even a single check can lead to vulnerabilities. In this talk, I will describe a new approach to protecting sensitive data even when application code is buggy or malicious. The key ideas behind my approach are to separate the security and privacy concerns of an application from its functionality, and to use language-level information flow control (IFC) to enforce policies throughout the code. This talk will cover LIO, an IFC-security language embedded in Haskell. LIO leverages Haskell's monads and strong type system to provide developers with a way to specify and enforce security policies on data. Building on LIO, I will then describe Hails, a server-side web framework that makes it easy to specify policies in a declarative way, alongside the application data model, and separate from the application functionality code. With Hails, developers can build server-side web applications that protect user date privacy and integrity, by construction.

Netflix is well known for championing the microservice model, but within the complex layers of dependencies is a hidden service: the caching layer. The Netflix customer experience relies heavily on caches to provide a high-volume, low latency, globally available data layer that backs our stateless services. Throughout a typical customer experience, from sitting down on the couch through playing a movie, caches play a role in every interaction. The use cases here range from session storage to video history to subscriber status, all of which benefit from the stability and fault tolerance of EVCache, the primary caching system in use at Netflix. The second part of the talk will peek under the hood of EVCache and its open source components: the EVCache client library, Rend, Memcached, and the not-yet-open-source Mnemonic. We will also look at sister projects that make up the rest of the EVCache ecosystem within Netflix. All of these components combined make up a high-volume, low-latency persistence system that fits many different use cases, even some where a cache might not normally be an obvious choice.

Asynchronous, event-driven programming is quickly becoming ubiquitous, and it comes in many forms: promises, futures, channels, actors, and more. These techniques help us build robust high-performance applications. However, what do we do when something fails? "Let it crash" is perfectly acceptable for many situations. However, what about the situation when one part of a multi-step process fails, and you need to undo the side effects of earlier steps? Are there patterns for reasoning about and resolving this problem? In 1986, Hector Garcia-Molina and Kenneth Salem published "Sagas", a paper describing how to improve the performance of long-lived transactions in DBMS systems by breaking them up into "sagas", a collection of smaller transactions which can be undone in the case of a failure. It is possible to adapt the saga pattern to solve our asynchronous recovery pattern. In particular, we will examine how to use it in both reactive stream-based systems and future-based systems with examples in Scala.

Tacit programming, or programming in the “point-free” style, allows you to define a function without reference to one or more of its arguments. Thanks to automatic currying, point-free definitions can be easy to write in Haskell, OCaml, and F#. But is point-free syntax just point-less? Ostensibly, tacit definitions can calibrate your code to the appropriate level of abstraction. But which level is most appropriate? When is a point-free definition better than its “pointed” variation? And when is it spectacularly worse? Let's be explicit about tacit programming. Let's learn eta-reduction to produce it. Let's develop our intuition for its expressive power. Let's hunt for it in trusted libraries. Let's probe its origins in John Backus' function-level programming. Let's see it amplified in Joy and J, languages designed for maximum quiet. Let's speak at length, about the unspoken.

Conversational interfaces are exploding in both development and use in 2016. Amazon's Alexa service and their Echo are at the forefront of this exciting new interaction model but Microsoft, Facebook and others have launched conversational bots recently. Who knows, maybe even Apple and Google will let us develop on their dueling voice assistant platforms soon! These new platforms are challenging for developers both because of the platform diversity but also because conversational user interaction is very different than interacting with a GUI. What are the differences between these platforms? What's the best way to get started? What kind of apps work well with conversational interfaces? What are some ways to make your app as human as possible? I've created several Slack integrations, worked with the Facebook Messenger bots API, developed applications on the Amazon Alexa service over the past year, and in 2015 I released go-alexa, a collection of libraries that help to create Alexa apps quickly in Go. In this talk we will cover the landscape of conversational applications, the major players and their platform strengths, some of the best practices I've learned, and walk through the creation of a basic Alexa Skill in Go.

In a connected world, synchronising mutable information between different devices with different clock precision can be a difficult problem. A piece of data may have many out-of-sync replicas but all of those should eventually be in a consistent state. For example, TomTom users, having personal navigation devices, smartphones, MyDrive website accounts, expect their navigation information be synchronised properly even in the occasional absence of network connection. Conflict-free Replicated Data Types (CRDTs) provide robust data structures to achieve proper synchronisation in an unreliable network of devices. They enable the conflict resolution being done locally at the data type level while guaranteeing the eventual consistency between replicas. In addition to an introduction to common CRDT types, the main focus is on the special subtype of CRDT-Set called OUR-Set (Observed, Updated, Removed), which we created to extend known CRDT sets with update functionality. I will demonstrate basic implementations of various CRDTs in Scala and enumerate subtle considerations which should be taken into account. I will also explain the advantages of these data structures to solve many synchronisation problems as well as their limitations.

There is no cloud — it's just someone else's computer. And you're storing all sorts of sensitive data on it, blindly trusting that this computer will only allow access to authorised users. What if it is compromised? End-to-end encryption avoids having to trust the servers. Although PGP/GPG encrypted email never went mainstream, secure messaging apps like WhatsApp, Signal and iMessage have shown that it is feasible for millions of people to use end-to-end encryption without being security experts. But how do these protocols actually work? In this talk, we will dig into the details of secure messaging protocols — to understand the threats against which they defend, and how cryptographic operations are combined to implement those defences in the protocol. If you have ever wondered what "forward secrecy" means, how key exchange works, or how protocols can ensure you're communicating with the right person (not an impostor like a "man in the middle"), this talk will clear things up. We will also look at taking end-to-end encryption to other areas beyond instant messaging. What would it take to build an end-to-end secure version of Google Docs, for example?

There is no cloud — it's just someone else's computer. And you're storing all sorts of sensitive data on it, blindly trusting that this computer will only allow access to authorised users. What if it is compromised? End-to-end encryption avoids having to trust the servers. Although PGP/GPG encrypted email never went mainstream, secure messaging apps like WhatsApp, Signal and iMessage have shown that it is feasible for millions of people to use end-to-end encryption without being security experts. But how do these protocols actually work? In this talk, we will dig into the details of secure messaging protocols — to understand the threats against which they defend, and how cryptographic operations are combined to implement those defences in the protocol. If you have ever wondered what "forward secrecy" means, how key exchange works, or how protocols can ensure you're communicating with the right person (not an impostor like a "man in the middle"), this talk will clear things up. We will also look at taking end-to-end encryption to other areas beyond instant messaging. What would it take to build an end-to-end secure version of Google Docs, for example?

Architects are tool builders. A famous example is the 20th century Spanish architect Antoni Gaudí, who built meticulous physical models of his world-famous buildings like Sagrada Familia and Casa Batlló. Armed with only rudimentary tools and manual calculations, Gaudí created buildings that still amaze people today. Imagine though, what if he had a computer cluster at his fingertips? At Flux we are designing a visual, flow-based programming environment to give architects access to the latest developments in distributed computing. The goal is to enable modern Gaudís to explore the vast extents of their imaginations. In this talk we'll explore ups and downs of building a web-based visual programming environment aimed at building designers. We'll also talk about the distributed execution system that backs it all.

Architects are tool builders. A famous example is the 20th century Spanish architect Antoni Gaudí, who built meticulous physical models of his world-famous buildings like Sagrada Familia and Casa Batlló. Armed with only rudimentary tools and manual calculations, Gaudí created buildings that still amaze people today. Imagine though, what if he had a computer cluster at his fingertips? At Flux we are designing a visual, flow-based programming environment to give architects access to the latest developments in distributed computing. The goal is to enable modern Gaudís to explore the vast extents of their imaginations. In this talk we'll explore ups and downs of building a web-based visual programming environment aimed at building designers. We'll also talk about the distributed execution system that backs it all.

For over half a century, NASA has been building, launching, and operating space missions where failure is not an option. NASA's track record of success is due in part to the standards and practices of the mission development cycle that emphasize extensive planning and project risk mitigation through advance design. Though space missions can span over a decade and dozens of subsystems, the principles that have produced mission success can also be used to improve outcomes of small-scale software development projects. Specifically heritage review, trade studies, success metrics, requirement development and their traceability to success, and critical review can be readily applied to mitigate project risks and ensure product delivery on schedule and budget. This talk summarizes how NASA flight projects are executed in the project and mission design phases, how these principles were applied in the development of Nanaya, a web app built in Django/Python/Postgres that uses mathematical modeling to predict the future of users' love and social lives, and the lessons that were learned in the process.

Gabrielle Crevecoeur dives into the world of NodeBots. Using Node.js, the Node Robotics frameworks, and an Arduino, Gabrielle walks participants through creating a bot, step by step. Although the NodeBot you build will respond to voice recognition, you'll leave able to create NodeBots with any functionality you like.

The need for gleaning answers from data in real-time is moving from nicety to a necessity. There are few options to analyze the never-ending stream of unbounded data at scale. Let's compare and contrast the core principles and technologies the different open source solutions available to help with this endeavor, and where in the future processing engines need to evolve to solve processing needs at scale. These findings are based on of our experience of building and continuing to build a scalable solution in the cloud to process over 700 billion events at Netflix, and how we have embark on the next journey to evolve unbounded data processing engines.

Have you ever hit a wall with REST? Does modeling your problem domain into CRUD-able entities feel like fitting a square peg into a round hole? Perhaps instead of modeling our services like little databases, we should instead model them like reactors over immutable event streams.

GraphQL is a static-strong-typed application data query language and runtime designed and used at Facebook to request and deliver data to mobile and web apps since 2012, and was redesigned prior to being open sourced in 2015. GraphQL delivers nearly all data for Facebook's primary iOS and Android apps, replacing our use of REST endpoints. This talk will briefly introduce GraphQL, the motivations for starting the project, and its impact on server and client code architecture at Facebook. Then, we will dive deeper into the design process of creating a new query language, from GraphQL experimental beginnings to lessons learned from years of use in production and then acting on those lessons for a full redesign before the recent open sourcing.

Although the idea of hygienic macro expansion appeals to many programmers, the details of hygienic expansion have scared away many language implementors. In fact, in the same way that lexical scope used to seem exotic and difficult to implement compared to dynamic scope---at least, until its implementation via closures became widely understood---the extra dimension of "macro scope" can seem mysterious. Historically, dynamic scope seemed obvious, because it involves a linear sequence of bindings, while lexical scope demands an implementation that matches the two-dimensional nature of nested expressions. Macro scope demands yet another dimension to binding. This talk aims to dispel the mystery of hygienic expansion: first, through a new explanation of macro scope based on "scopes sets"; and second, by walking through the implementation of a macro expansion using scope-sets.

Ethnomusicologists face a dilemma: either shoehorn African music into European notation, or create custom DSLs that can only be understood by a select band of European ethnomusicologists. Algomusicologists can solve this problem, because we have principled ways of modelling specific idioms in terms of general computation. What's more, our models can be executed to generate actual music. Simha Arom is a French-Israeli ethnomusicologist. In the book from which the title of this talk is borrowed, he describes the principles underlying the musical system of traditional central African polyphony and polyrhythm. Arom invented ingenious recording techniques for deconstructing and systematising musical cultures that had no previous tradition of musical theory. He tested his models by using them to recreate music and inviting central African musicians to critique the results. This talk will argue that music-as-code is an ideal way to represent Arom's insights. I will show the full truth in the Lévi-Strauss quote with which Arom prefaces his book: "The proof of the analysis is in the synthesis." Programming has played its part in the homogenisation of global culture, but the universality of the lambda calculus also affords a golden opportunity for code to become a point of interchange between formerly incompatible musical systems.

Metrics are great, and measuring things can provide tremendously useful insights. But there's a problem: metrics lie to you. Metrics just report the numbers that were measured. Analyzing those numbers is up to us, and that analysis can go wrong in so, so many ways. Learn how to arm yourself against human intuition, interpreter pauses, routing, instrumentation lag, and other issues. Don't get so caught up in instrumenting that you lose sight of why metrics exist! Make sure your metrics are telling you actionable information, instead of just accurate numbers.

Writing correct concurrent code is hard. Debugging incorrect concurrent code is even harder. The Go race detector, introduced in Go version 1.1, is one cool tool that makes both easy to do in Go programs. Race conditions are arguably the most elusive programming errors, so how does a tool that detects these across programs operate under the hood? In the case of the Go race detector, with compiler instrumentation of the program and a run-time library that watches for “racy” memory accesses. This talk will delve into the internals of the data race detector — both the instrumentation by the compiler and the happens-before algorithm implemented by the run-time module to detect data races. We will touch upon how the alternative to such a dynamic data race detector — a static data analyzer — differs in design, and the pros and cons of each approach.

Industrial computer-controlled knitting machines are churning out seamless three-dimensional fabric objects as you read this -- think gloves, sweaters, sportswear, furnishings, architectural fabrics, and plushies. But right now the programming languages for these machines are terrible. With a knitting machine, complex structures are formed with a very limited set of low-level machine operations. Thinking on the level of those machine operations becomes untenable pretty quickly when you start trying to make real objects. How can we ensure knittability? Can we encode constraints in an understandable way? Can we optimize production speed? We'll look at several ways to describe knit structures and generate machine instructions for their fabrication, including both the delightfully arcane language that ships with the machine and the language from our SIGGRAPH 2016 technical paper, "A Compiler for 3D Machine Knitting."

We present Tezos, a generic and self-amending crypto-ledger which can instantiate any blockchain based ledger. The operations of a regular blockchain are implemented as a purely functional module abstracted into a shell responsible for network operations. Bitcoin, Ethereum, etc. can all be represented within Tezos by implementing the proper interface to the network layer. Most importantly, Tezos supports meta upgrades: the protocols can evolve by amending their own code. To achieve this, Tezos begins with a seed protocol defining a procedure for stakeholders to approve amendments to the protocol, including amendments to the voting procedure itself. This is not unlike philosopher Peter Suber's Nomic, a game built around a fully introspective set of rules. In addition, Tezos's seed protocol is based on a pure proof-of-stake system and supports Turing complete smart contracts. Tezos is implemented in OCaml, a powerful functional programming language offering speed, an unambiguous syntax and semantic, and an ecosystem making Tezos a good candidate for formal proofs of correctness.

Poetry can take many forms but could be defined as a delicate balance between constraints and expression. Computers are pretty good at constraints, less so at expression. The general problem of cracking the structure and meaning of a text has been one of the goals of linguistics, and Natural Language Processing. This had first been addressed in a reductionist way, by decomposing a sentence, counting, matching then, later, by learning from evidence and statistics. Or, as it has been shown, lately to be more and more effective, by training neural networks with a minimal set of assumptions - as was shown by the seminal paper “Natural Language Processing (almost) from Scratch”. In this talk we'll see how to follow these techniques to spot poetry in unlikely textual places, or generate it (almost) from scratch, using a minimal set of assumptions, hoping for the meter and rhyme rules to emerge. Along the way we'll touch on topics such as the impossible definition of poetry and the tension between simple, classical rules, and deep learning models that can defy interpretation.

DDoS attacks often grab the headlines when they take down an important website. Sadly, DDoS experts usually keep the attack information to themselves. All the DDoS mitigation resources are centralized in a hands of a few large DDoS mitigation vendors. Without the details internet operators are unable to distinguish a real danger from an empty threat. At CloudFlare we deal with DDoS attacks every day and over the years we've gained a lot of experience. While some of our DDoS defenses require significant investment - e.g. buying more network capacity - many mitigations can be implemented in software. In this talk we'll discuss what we learned about the L3 (Layer 3 OSI stack) IP spoofing. We'll explain why L3 attacks are even possible in today's internet, what a direct L3 attack may look like and how it is different from a reflected attack. We'll describe our attempts to trace IP spoofing and why the attribution is so hard. Our architecture allows us to perform attack mitigations in software. We'll explain a couple of effective L3 mitigations techniques we've learned over the years. While L3 attacks are a real danger to the internet operators, they don't need to be. With a bit of cooperation and couple of technical tricks maybe we can finally save the internet and fix the IP spoofing problem for all.

There are a lot of competing ideas about what makes a language “good”. This is because we as language designers still have no idea what we're doing. The design of Tulip is based on careful study of a wide variety of popular and esoteric programming languages over about 4 years. Its runtime takes cues from Erlang, and its syntax is slightly like ML, but with a few key innovations designed for repl ergonomics. Tulip is one of the new languages to come out of the language community Snek, emphasizing languages by minority designers and implementers.

There are a lot of competing ideas about what makes a language “good”. This is because we as language designers still have no idea what we're doing. The design of Tulip is based on careful study of a wide variety of popular and esoteric programming languages over about 4 years. Its runtime takes cues from Erlang, and its syntax is slightly like ML, but with a few key innovations designed for repl ergonomics. Tulip is one of the new languages to come out of the language community Snek, emphasizing languages by minority designers and implementers.

Until recently making a compiler from scratch that produced fast native executables with a well-tuned garbage collector meant getting really comfy with C. Rust has risen to the top of the heap as a developer-friendly systems programming language that allows the same degree of control as C but is much more expressive and sports an innovative type system that avoids the pitfalls of pointer arithmetic. Surprisingly though it hasn't seen much uptake among language implementors. This talk will present a compiler for a small, garbage-collected Scheme-like language written entirely in Rust. It will explore the pros and cons of using Rust for language development and show benchmarks comparing the garbage collector and runtime up with similar well-known languages written in C.

What do you do when you outscale your monitoring systems, and need to upgrade -- while keeping the lights on 24/7 around the world? This talk will walk through the ins and outs of architecting a real-time data processing architecture from the ground up in order to handle critical, high-traffic monitoring load across a distributed backend, along with several war stories of where it went well, failed horribly, and saved our bacon. Prepare for a magical mystery tour of distributed delights, diving into real-time pipeline architectures and building Go-based microservices. We'll cover how interoperability contracts, dynamic configuration and service discovery allow you to develop and operate at speed, plus how this all fits on top of a rock-solid foundation of Kafka with ElasticSearch. You'll leave armed with a toolbox of ideas to build and monitor your own microservice-based ecosystem.

Lot's of people know about Turing Machines and the Lambda Calculus and that they both can express any computable function, but often don't really understand what that means. An Unlimited Register Machine is a simple model of a computer, still quite idealised, that is turing equivalent also. The philosopher Dan Dennett, in his book Intuition Pumps and Other Tools For Thinking, devotes a rather large section to URMs titled The Seven Secrets Of Computing Power Revealed. The hope is that by simulating the simplest possible register machine and building up to complex algorithms you can understand what it means to compute. In the talk I treat math(s) and 'programming' as equal citizens in terms of explaining the idea and end with an easy to understand concrete implementation of a Universal URM (via a neat way of Gödelizing programs, ie turning them into numbers).

Programmatic and direct manipulation systems have distinct and complementary strengths, but users must typically choose one over the other or use some ad-hoc combination of systems. As an attempt to bridge this divide, we are developing an interactive programming system called Sketch-n-Sketch for creating Scalable Vector Graphics. Sketch-n-Sketch offers a high-level, functional programming language paired with GUI-based tools for manipulating program output: these tools help to encode user intent by semi-automatically rewriting the program with new relationships, and help to preserve existing relationships in the program when output values are directly manipulated. The resulting workflow allows for prototyping a design much like in typical GUI-based tools and then iteratively adding more structure to the program with guidance from the system. In this talk, we will demo Sketch-n-Sketch, describe our approaches to the technical challenges, and discuss ideas for combining programmatic and direct manipulation in other settings.

Cryptography is an ancient idea, but modern approaches which draw from deep mathematics and have only started to pop up in the past decade. This talk will provide a broad survey of approaches for acting on encrypted data without holding a private key to the data, including property-preserving encryption, searchable symmetric encryption, functional encryption, and homomorphic encryption. It will also provide a historical context for the development of cryptography, addressing such questions as whether cryptography is "discovered" or "invented", what algorithms extraterrestrial cryptographers might use, and whether we can create encrypted Turing-complete programs which act only on ciphertexts.

Kittens is a proof of concept library built on top of shapeless[1] and cats[2] as an experiment of combining generic and functional programming. It can help Scala programs achieve higher flexibility with datatypes without compromising safety. Through several example projects using kittens, this talk will provide a peek at the power of datatype generic functional programming.

Why do some tools continue to reward mastery after years of use, while others seem to become clunkier as we learn them? One answer is that rewarding tools often display reproducibility: given the same inputs, the tool always does the same thing. Reproducibility lets us build clear mental models of the tool's behavior. We learn to "think in Git", for example, rather than simply guessing at a command or function call and puzzling over the results. Git, React, and Bundler all rely deeply on reproducibility. As three quick examples: Git will produce the same hash for a file committed on two different machines; React relies on component functions re-rendering the same virtual DOM when called multiple times; and Bundler's entire purpose is to reliably reproduce package lists and installed package sets on different machines. In this talk, we examine these tools' reproducibility in detail. We then reach two conclusions: first, that their success is a large-scale version of the same advantage offered by pure (that is, reproducible) functions; second, that we can use reproducibility as a guide for building new tools.

Whether you're using plain old OS threads or a userspace threading model, understanding the subtleties of scheduling and how it affects parallel programs can be tricky. As systems and performance engineers, there are many questions we can ask: Can we quantify the tradeoffs between native threads and green threads? How expensive are context switches really? How can a scheduler trade off throughput and latency? How should we evaluate scheduler performance? And what do we really mean by performance, anyways? Let's talk about the essentials of scheduling in the Linux kernel, and then take a deep dive into the schedulers implemented in the Erlang and Go runtimes. We'll compare the design decisions they make, and get an idea of the fundamentals of scheduler design. Along the way, we'll discuss those questions, and explore how we can actually analyze scheduler behavior in action.

It's 2016, but our approach to programming isn't much different from 1976. It's characterized by text in files, syntax errors, bugs, and documentation on the side. The feedback cycle may be smaller but fundamentally it hasn't changed much. We can do better. Panda gets away from loops, ifs, mutable objects by operating on streamed data. Using a system which knows what you can do next programming is like a dialogue. Ultimately, we'd replace most simple programming tasks by just selections through an adoptive touch UI. Panda is a reactive concurrent streamed-evaluated object-oriented functional based distributed language system. It avoids obsessing about types, math, and recursions, is instantly parsed into a typed cost-aware datalog that compiles to javascript. Expressions are cheap lightweight concurrent processes. Like Erlang, these together with global messaging forms the basis of distributed computing platform. If persisted, messages form an implicit event sourced data storage, with built-in key-value indices. On this, a simple integrated wiki-style code editor, stores and shares functions online. 10 lines implements a simple distributed web-based real-time chat.

This past year, I've been testing out ways to bring more open source to the academic research space. It hasn't been easy -- the research world is full of competition, private data and a cutthroat need to publish. However, we found some open source champions, invested in them through workshops, summits and ongoing one on one mentorship as they learn to work openly on their research. In this talk, I'll share some of the lessons learned building an open source movement in academia.

The Wikimedia Foundation is a non-profit and charitable organization driven by a vision of a world where every human can freely share in the sum of all knowledge. Each month Wikimedia sites serve over 18 billion page views to 500 million unique visitors around the world. Among the many resources offered by Wikimedia is a public-facing API that provides low-latency, programmatic access to full-history content and meta-data, in a variety of formats. Commonly, results from this system are the product of computationally intensive transformations, and must be pre-generated and persisted to meet latency expectations. Unsurprisingly, there are numerous challenges to providing low-latency storage of such a massive data-set, in a demanding, globally distributed environment. In this talk, we will cover the Wikimedia content API, and it's use of Apache Cassandra, a massively-scalable distributed database, as storage for a diverse and growing set of use-cases. Trials, tribulations, and triumphs, of both a development and operational nature will be discussed.

“Microservice” is the hype word of the day, but if you're convinced there's value in breaking down large systems into small services, this workshop may be just what you're looking for. Lagom is the latest framework brought to you by LightBend (formerly Typesafe), and it's designed to simplify the development and deployment of microservices over the JVM. It helps us developers in three areas: writing, distributing and deploying services. In this workshop, you will create three services that collaborate to produce a meaningful result to our hypothetical users. Exercises will be done in Java, and we will have a peek into the underlying components of Lagom, such as Akka and Cassandra.

Take a break from the daily grind and learn how to make music with TidalCycles. TidalCycles is a pattern-based live coding language written in Haskell. This workshop will cover the installation of TidalCycles if not installed prior to the workshop (see http://www.tidalcycles.org). Learn how to use TidalCycles to create patterns that manipulate samples in the Dirt sample engine, then learn about the various functions built into TidalCycles to manipulate those patterns to create interesting sounds. We will also cover using the new hybrid engine SuperDirt, which combines Dirt with the power of the Supercollider synthesis engine. Have fun generating your own dance floor hits or explore a more experimental side of music. Whichever you choose, you will have fun creating it.

Join us for a powerful learning experience where you will participate in helping to solve a sample programming problem. There are so many new languages to learn about at strangeloop and this is your chance to come and try them out. A Coding Dojo is a get-together where programmers follow a pattern similar to the martial arts dojo to practice their skills. In this Coding Dojo you will get an opportunity to practice new languages with leading experts on hand to guide and assist. We will be using the Randori/Mobbing format, to let as many participants as possible do actual coding.

Unikernels are a new mechanism to deploy lightweight, scalable, secure microservices that offer big functionality for relatively low cost. To do so, they allow us to compile our services to run directly on virtual “bare metal”, throwing away all the parts of the application and operating system stack we don't need. Don't want a file system? Throw out all that code, and the disk driver, too. Why pay (in cost, size, performance, or exploits) for all the stuff you don't use? In this workshop, we'll talk the soup to nuts of designing, building, testing, and deploying microservices using unikernels. We'll start by showing a simple microservice design using the HaLVM, and then walk through how we build, test, and deploy it. For attendees with EC2 credentials, we'll even show how to load it into Amazon's cloud. Not a Haskell fan? We'll show how to perform the exact same steps using Mirage (OCAML), the rump kernel (C), IncludeOS (C++), and other unikernels. Want to further explore the design space? Let's extend our base microservice to perform any number of interesting tasks: authentication, routing, caching, computation … you name it, and we'll walk you through the process of building and deploying your microservice. Experience with unikernels is not required for this class, but experience with unikernel-capable languages and tools (Haskell's Cabal, OCAML's OPAM, Make / GCC / ld, etc.) is strongly recommended.

Unikernels are a new mechanism to deploy lightweight, scalable, secure microservices that offer big functionality for relatively low cost. To do so, they allow us to compile our services to run directly on virtual “bare metal”, throwing away all the parts of the application and operating system stack we don't need. Don't want a file system? Throw out all that code, and the disk driver, too. Why pay (in cost, size, performance, or exploits) for all the stuff you don't use? In this workshop, we'll talk the soup to nuts of designing, building, testing, and deploying microservices using unikernels. We'll start by showing a simple microservice design using the HaLVM, and then walk through how we build, test, and deploy it. For attendees with EC2 credentials, we'll even show how to load it into Amazon's cloud. Not a Haskell fan? We'll show how to perform the exact same steps using Mirage (OCAML), the rump kernel (C), IncludeOS (C++), and other unikernels. Want to further explore the design space? Let's extend our base microservice to perform any number of interesting tasks: authentication, routing, caching, computation … you name it, and we'll walk you through the process of building and deploying your microservice. Experience with unikernels is not required for this class, but experience with unikernel-capable languages and tools (Haskell's Cabal, OCAML's OPAM, Make / GCC / ld, etc.) is strongly recommended.

In this workshop, which assumes only basic Clojure knowledge (see Clojure Koans or any of the excellent introductory Clojure books), we'll dig into how Clojure macros work, some tricks of the macro-writing trade, and the inherent tradeoffs we must accept when we reach for macros as a tool. The workshop will include lecture and Q&A time, as well as plenty of hands-on exercises to apply and practice the concepts we talk about. Come with a laptop or a friend to pair with, and you'll leave with a solid grasp of when and how to use macros (and also your laptop or friend!).

Functional programming is all the rage these days, but our codebases, libraries, and built-in methods are predominately Object-Oriented. Using OO syntax with functional constructs, we can write in a style compatible with either paradigm and enjoy the benefits of both. We will explore disjunction, monoids, monads, and other algebraic abstractions to produce highly composable, safer, and simpler code. And we'll do it all in JavaScript.

React.js is one of the hot topics in our industry. It challenges the status quo introducing new ways of thinking about and building dynamic web applications. In this workshop we'll explore the pragmatic application of React.js and especially how to use it with a functional approach minimizing mutable state and side effects. In this workshop we'll discuss: React.js - primarily functional use, Modularization, Composition, Immutable.js, Redux, RxJS, Performance considerations, Trade-offs. This interactive workshop is ideal for intermediate javascript developers who want to grow in their knowledge and understanding of React.js and functional techniques for writing solid, performant, and maintainable code.

Deep learning is a powerful family of tools that has had great impact in solving problems ranging from object recognition to machine translation to playing Atari or Go games. However, it is traditionally treated as something of a black box: you put in as much data as you can, twiddle some knobs, wait for results, and repeat until results are good. There's an emerging area of research developing meta-tools for understanding what's happening in a deep learning system through visualization. Not only do such visualizations make this area more approachable and understandable for beginners, but the explorations they open up into the inner workings of deep learning can lead to valuable research insights. We'll start with a brief visual introduction to essential concepts of deep learning, and then take a tour of several other visualization tools, playing with systems that can illustrate what a deep learner has learned, and finally demonstrating tools that can help debug deep learning applications. Many of these visualizations are hands-on, so bring a laptop with an up-to-date browser (and few open tabs) for the best experience. Whether you're a professional data scientist or just someone interested in what this “deep learning” thing everyone's buzzing about actually means, if you're curious in this area, you're very welcome to explore with us at this workshop.

This workshop will show how to deploy and scale applications in containers using reusable, adaptable patterns. We will run a sample app on a single node with Compose. Then, we will add scaling and load balancing. We will see how to provision a cluster of Docker nodes, and deploy the application on that cluster. We will see how to perform common operation tasks, and see what options are available to achieve high availability. The whole workshop will use "real-world" demo applications with web frontends, web services, background workers, and stateful data stores, in order to cover a wide range of use cases. You won't need to pre-install Docker before the course: each student will be given credentials to connect to an individual cluster of virtual machines. So all you need is a computer with a SSH client! An earlier version of this workshop was delivered at StrangeLoop in 2015. This version will be significantly different. It will focus primarily on cluster features that didn't exist last year. It will leverage on overlay networking and other significant improvements in the Docker platform. All the material for this workshop (scripts, slides, sample code) is available on https://github.com/jpetazzo/orchestration-workshop/. If you attended the Docker orchestration workshop last year and wonder what's new under the sun, you can check the commit history in this repo to make up your mind.

Want to learn simple everyday ways to support people in your workplace and community? The Ally Skills Workshop teaches simple everyday ways for people with societal advantages to support people who are targets of systemic oppression, including women of all races, people who are ethnic minorities, people with disabilities, LGBTQ folks, and primary parents (especially mothers). This is a fun, thought-provoking, and highly interactive workshop that will give you food for thought and a desire to learn more. This workshop is focused on techniques that work well in technology-related organizations and online communities, including software companies, free and open source software communities, Wikipedia-related projects, coworking spaces, and hacker and maker spaces. The workshop works best when people with a wide variety of experiences and backgrounds attend. Everyone is welcome to attend if you have an interest in ally skills. You may want to learn ally skills to practice them yourself, or you may want to learn how to teach ally skills to others. If you are a member of a marginalized group, you are especially welcome. This workshop gives you a space to share your knowledge and experience in a respectful and supportive environment.

Rust is a language with a new vision of systems programming. It gives you low-level control and predictability but also provides the safety and ergonomics of much higher-level languages (like Ruby or Python). This workshop gives an introduction to Rust from the ground up, with a focus on ownership and borrowing. We'll cover how Rust's type system works and how it prevents memory safety errors as well as common problems with parallel programming, like data races. By the end of the day, you should be well on your way to making your own Rust project.

Learn how to use JavaScript to build high-quality, performant applications for iOS and Android with React Native! This three-hour workshop introduces the React Native, a framework for writing cross-platform applications using JavaScript. Mobile components, styling, and native APIs such as local storage are discussed, and participants will build a simple weather forecast application for iOS and Android. Additionally, we'll discuss the foundational concepts that make React Native work, and how it differs from other cross-platform solutions. The workshop assumes some prior familiarity with React and JavaScript, and requires a working developer environment. Attendees with previous mobile experience and ability to read JavaScript are also welcome. Pre-attendance instructions will be provided.

We have a lot of great front-end technologies today, and many interesting ways to store and process data in the backend. But often the abstractions break down when we try to build a simple architecture that processes and visualizes data as its primary goal. We might be able to create a nice frontend, but the ingestion and storage is a mess. Or the other way around, depending on the individual's background. Most recently, GraphQL has shown that this barrier exists - a lot of people would love to use it, but not that many do, since they are missing the capable backend that can run the queries. In this workshop I'll introduce a clean architecture for ingesting, storing, processing and visualizing data - built on PostgreSQL, GraphQL, React and d3. I'll talk about the trade-offs, the weaknesses, and what I think is a good set of best practices when starting a new data-intensive, frontend-heavy project using these technologies. This workshop builds on my experience scaling PostgreSQL for many different kinds of companies, as well as my personal interest and background in data analysis and visualization using React and d3. Basic knowledge of the React-based front-end stack, as well as PostgreSQL is welcome, but not necessary - this workshop is intermediate level and hopes to give you a good starting point to dive deeper into the individual pieces, or see a good example case study for you to take inspiration from.

TBA

Angular2 comes with great performance improvements and better tools than ever to build interactive data visualizations for the web. Check out how you can leverage ngAnimate, RxJS and Angular2 change detection to tell a story 60fps.

Messaging systems built on the idea of a distributed commit log such as Apache Kafka and Amazon Kinesis offer a powerful approach for building robust, real-time systems. However, because of their unique nature there are particular techniques required to use them effectively. This talk will catalog approaches used in practice to address topics such as: dealing with duplicate event delivery, merging & splitting of shards, poison events, exception handling, detecting failed workers, performing rapid failover, and providing facilities for debugging. These approaches provide a foundation for using distributed commit logs not just for applications such as click-stream analysis but for transaction processing.

Despite the media attention given to the diversity in tech problem, many technology practitioners don't see how a lack of diversity affects their daily lives. So, it is not surprising that they neither understand the magnitude of the problem nor how they can help fix it. However, the skills needed to debug software are directly applicable to making technology companies more inclusive and diverse.

It's hard to imagine a modern developer workflow without a sufficiently advanced build system: Make, Gradle, Maven, Rake, and many others. In this talk, we'll discuss the evolution of build systems that leads to distributed build systems. Then, we'll dive into how we can build a scalable system that is fast and resilient, with examples from Google. We'll conclude with the discussion of general challenges of migrating systems from one architecture to another.

This talk makes the case that Guile is a delightful medium for making crafty programs, from the most ephemeral scripts to long-lived systems that you can rely on for years. Guile takes the elegant Scheme programming language, integrates it with the POSIX environments that you know and loathe and love, and wraps it all up in a responsive, hackable environment that nurtures programs from the small up to the large. Guile hacker will give you a gentle introduction to the language as they lead you through the process of building cool stuff in Scheme. With all this going for it, maybe you will choose to make your next program in Guile!

Functional data structures are awesome--they're the foundation of many functional programming languages, allowing us to express complex logic immutably and efficiently. There is one unfortunate limitation: these data structures must fit on the heap, limiting their lifetime to that of the process. Several years ago, Datomic appeared as the first functional database that addresses these limitations. However, there hasn't been much activity in the realm of scalable (gigabytes to terabytes) functional data structures. In this talk, we'll first review some of the fundamental principles of functional data structures, particularly trees. Next, we'll review what a B tree is and why it's better than other trees for storage. Then, we'll learn about a cool variant of a B tree called a fractal tree, how it can be made functional, and why it has phenomenal performance. Finally, we'll unify these concepts to understand the Hitchhiker tree, an open-source functionally persistent fractal tree. We'll also briefly look at an example API for using Hitchhiker trees that allows your application's state to be stored off-heap, in the spirit of the 2014 paper "Fast Database Restarts at Facebook".

Functional Programming paradigm produces more reliable and readable code, it also helps us think about the problem at hand more before deciding how to solve it. However, a lot of us got introduced to object oriented programming first, so it can be a pain to switch our mindset into functional programming. I will be talking about some of the concepts in functional programming and how to get started with existing programming knowledge.

We're going to use search as a case study on how to reason about performance before coding. Imagine you're building a search engine from scratch. There are maybe a trillion documents on the Internet. If each each document is 10kB, that's 10 petabytes of data! How do you query 10PB of data in a fraction of a second? That might take years to implement, but it's surprisingly easy to reason about the performance of various possible designs. We'll talk about how to estimate performance using back of the envelope calculations that can be done in minutes or hours, even for applications that take months or years to implement. In particular, we'll walk through a core search algorithm used in Bing, discuss how we initially estimated the performance and decided the system was worth building, and how the actual performance compared to the estimated performance. We'll also talk about why the class of algorithm we're discussing has been considered obsolete as a core search engine technology for almost two decades, despite having reasonable performance characteristics in theory and practice.

NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second. In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.

The EcmaScript standard is now on a yearly release cycle. With ES6 complete and ES2016 ratified, we have a ton of awesome new features to use in our daily software development. In this training, we'll learn about the features you're likely to use and benefit from on a day-to-day basis. You'll get hands on experience trying out these new features with a test suite you'll be expected to make pass. After this training, you'll be able to go back to your projects and add support for ESNext code today. This is a very hands-on training and you'll need to make sure that you're machine is ready. You will be coding and running code. Please ensure that you have git, Node, npm, and a text editor / IDE installed on your machine. With that, you'll be ready to rock and roll.

Unikernels are a new mechanism to deploy lightweight, scalable, secure microservices that offer big functionality for relatively low cost. To do so, they allow us to compile our services to run directly on virtual “bare metal”, throwing away all the parts of the application and operating system stack we don't need. Don't want a file system? Throw out all that code, and the disk driver, too. Why pay (in cost, size, performance, or exploits) for all the stuff you don't use? In this workshop, we'll talk the soup to nuts of designing, building, testing, and deploying microservices using unikernels. We'll start by showing a simple microservice design using the HaLVM, and then walk through how we build, test, and deploy it. For attendees with EC2 credentials, we'll even show how to load it into Amazon's cloud. Not a Haskell fan? We'll show how to perform the exact same steps using Mirage (OCAML), the rump kernel (C), IncludeOS (C++), and other unikernels. Want to further explore the design space? Let's extend our base microservice to perform any number of interesting tasks: authentication, routing, caching, computation … you name it, and we'll walk you through the process of building and deploying your microservice. Experience with unikernels is not required for this class, but experience with unikernel-capable languages and tools (Haskell's Cabal, OCAML's OPAM, Make / GCC / ld, etc.) is strongly recommended.

Dynamically scheduled tasks are at the heart of PagerDuty's microservices. They deliver incident alerts, on-call notifications, and manage myriad administrative chores. Historically, these tasks were scheduled and run using an in-house library built on Cassandra, but that solution had begun to show its age. Early in 2016, the Core team at PagerDuty built a new Task Scheduler using Akka, Kafka, and Cassandra. After six weeks in development, the Scheduler is now running in production. This talk discusses how the strengths of the three technologies were leveraged to solve the challenges of resilient, distributed task scheduling. This talk will present a number of distributed system concepts in the real-world context of the Scheduler project. How can you dynamically adjust for increased task load with zero downtime? Can you guarantee task ordering across many servers? Do your tasks still run when an entire datacenter goes down? What happens if your tasks are scheduled twice? Attendees can expect to see how all of these challenges were addressed. Some familiarity with distributed queueing and actor systems will be helpful for attendees of this talk.

You can program with high agility and end up with a robust, maintainable program. This talk will show you how to use Clojure and the new spec library to write programs that behave as expected, meet operational requirements, and have the flexibility to accommodate change.

Do you ever look at a popular app and think that it doesn't look so hard to make? Do you just never getting around to making an app yourself? Luckily for you, you can take the plunge and learn how to make a quick and simple iOS app! In this workshop, you will get a crash-course in Swift by creating a Boggle-like iOS app. You'll become familiar with using Apple's Xcode as well as learn to structure a mobile app. Not only will you leave with a working app that you can play in between sessions, but you'll also have dozens of ideas on how to expand the app and grow your skills. New and old programmers alike will awaken their creative side and be inspired to create the next, new popular app!