Wednesday, Sept 24th, PreconferenceCoding DojoDate: 2015-09-24 09:00Room: Grand AFormat: coding dojoTrack: languages

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 programmersfollow 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 onhand to guide and assist. We will be using the Randori/Mobbing format, to let as many participants as possible do actual coding.

Llewellyn Falco (@llewellynfalco) - spun labs

Llewellyn Falco is an Agile Technical Coach specializing in Legacy Code and Test Driven Development. He is the creator of the open source testing tool ApprovalTests(www.approvaltests.com ), co-founder of TeachingKidsPrograming ( www.teachingkidsprogramming.org ) and a Pluralsight author.

Future Programming Workshop

BayesDB: Query the Probable Implications of Data

Date: 2015-09-24 09:10Room: Grand DEFFormat: future of programmingTrack: fpw

Statistics and machine learning are part of many new systems, but have been described as the "high interest credit card of technical debt." Is it possible to make statisticalinference broadly accessible to non-statistician programmers without sacrificing mathematical rigor or inference quality? BayesDB is a system that enables users to querythe probably implications of their data as directly as SQL enables them to query the data itself. This presentation focuses on BQL, an SQL-like query managed forBayesian data analysis that answers queries by averaging over an implicit space of probabilistic models. The demonstration focuses on analysis of a public database ofEarth satellites.

Richard Tibbetts - MIT

An Overview of Probabilistic Programming

Date: 2015-09-24 10:00Room: Grand DEFFormat: future of programmingTrack: fpw

Probabilistic inference is a widely-used, rigorous approach for processing ambiguous information based on models that are uncertain or incomplete. However, models andinference algorithms can be difficult to specify and implement, let alone design, validate, or optimize. Additionally, inference often appears to be intractable. Probabilisticprogramming is an emerging field that aims to address these challenges by formalizing modeling and inference using key ideas from probability theory, programminglanguages, and Turing-universal computation.

This talk will illustrate the common underlying principles of probabilistic programming using three research platforms:

1. BayesDB, a Bayesian database that enables users to directly query the probable implications of data tables without training in statistics. It provides BQL, an SQL-like language for Bayesian data analysis, and MML, a minimal language for building generative population models by combining automatic model-buildingtechniques with qualitative constraints and custom statistical code. BayesDB has been applied to problems such as cleaning and exploring a public database of Earthsatellites and assessing the evidence for microbial biomarkers of Kwashiorkor, a form of severe malnutrition.

2. Picture, an imperative probabilistic language for 3D scene perception. Picture uses deep neural networks and statistical learning to invert generative models based oncomputer graphics. 50-line Picture programs can infer 3D models of human poses, faces, and other object classes from single images.

3. Venture, an integrated platform that aims to be sufficiently expressive, efficient, and extensible for general-purpose use. It provides VentureScript, a language thatgives users fine-grained control over both modeling and inference, and defines a common interface for integrating components written in other probabilisticlanguages. Recent applications include structure discovery from time-series via Gaussian processes and reflective AI techniques such as Bayesian optimization.

Vikash K. Mansinghka - MIT

Vikash Mansinghka is a postdoctoral researcher at MIT, where he leads the Probabilistic Computing Project. Vikash holds S.B. degrees in Mathematics and in ComputerScience from MIT, as well as an M.Eng. in Computer Science and a PhD in Computation. He also held graduate fellowships from the National Science Foundation andMIT's Lincoln Laboratory. His PhD dissertation on natively probabilistic computation won the MIT George M. Sprowls dissertation award in computer science, and hisresearch on the Picture probabilistic programming language won an award at CVPR. He co-founded a venture-backed startup based on this research that was acquired bySalesforce.com and was an advisor to Google DeepMind. He served on DARPA's Information Science and Technology advisory board from 2010-2012, and currentlyserves on the editorial boards for the Journal of Machine Learning Research and the journal Statistics and Computation.

The Gamma: Programming tools for data journalism

Date: 2015-09-24 12:20Room: Grand DEFFormat: future of programmingTrack: fpw

Computer programming may not be the new literacy, but it is finding its way into many areas of modern society. In this submission, we look at data journalism, which is adiscipline combining programming, data analysis and traditional journalism. In short, data journalism turns articles from a mix of text and images into something that ismuch closer to a computer program.

Most data journalists today use a wide range of tools that involve a number of manual steps. This makes the analysis error prone and hard to reproduce. In this video, weexplore the idea of treating a data driven article as an executable program. We look how ideas from programming language research can be used to provide better tools forwriting (or programming) such articles, but also to enable novel interactive experience for the reader.

The project also makes data journalism more accountable and reproducible. We let the reader verify how exactly are the visualizations generated, what are the data sourcesand how are they combined together.

Tomas Petricek - University of Cambridge

Tomas is a computer scientist, book author and open-source developer. He wrote a popular book called "Real-World Functional Programming" and is a lead developer ofseveral F# open-source libraries, but he also contributed to the design of the F# language as an intern and consultant at Microsoft Research. He is a partner at fsharpWorks(http://fsharpworks.com) where he provides trainings and consulting services.

Tomas recently submitted his PhD thesis at the University of Cambridge focused on types for understanding context usage in programming languages, but his most recentwork also includes two essays that attempt to understand programming through the perspective of philosophy of science.

Constraint Logic Propagation Conflict Spreadsheets

Date: 2015-09-24 13:10Room: Grand DEFFormat: future of programmingTrack: fpw

We present a live coding system that bridges constraint logic programming with data-centric reactivity. Relations are treated as tables. A module is a table (or sheet oftables) grouped by columns. We enable speculative what-if analysis by locally overriding facts.

Facts may be associated values and constraints. Aggregation operators, such as sums, specify a value by folding over unifying substitutions. Constraints propagate amongrelated facts limiting satisfiable domains. When a domain becomes empty, provenance tracking provides conflict maintenance and resolution.

William Taysom - Power Auctions LLC

William Taysom as a senior software engineer with Power Auctions has developed combinatorial pricing solvers responsible for allocating billions of dollars of spectrumlicenses across the world. He has moonlighted as a programming language researcher ever since his days as a Philosophy student at CMU and an associate at the FloridaInstitute for Human and Machine Cognition.

Eve

Date: 2015-09-24 14:00Room: Grand DEFFormat: future of programmingTrack: fpw

TBD

Chris Granger - Eve

Apparatus: A Hybrid Graphics Editor / Programming Environment for Creating Interactive Diagrams

Date: 2015-09-24 15:00Room: Grand DEFFormat: future of programmingTrack: fpw

An interactive diagram can be an effective way to communicate a mental model, because it can convey a way of seeing a problem or system. Currently, to create aninteractive diagram one must write code to procedurally draw the diagram and respond appropriately to user input. Writing this code can take hours or days. Apparatusaims to reduce the time to create an interactive diagram from hours to minutes.

Apparatus combines the direct manipulation capabilities of a vector graphics editor with the dataflow capabilities of a spreadsheet. Through this hybridization, Apparatussupports both spatial and symbolic ways of working in tandem. Dataflow defines the state space of a diagram, algebra driving geometry. Dragging shapes moves throughthis state space, geometry driving algebra. Instead of function calls or object-oriented inheritance, Apparatus uses a "call by copying" pattern for diagram reuse. Reuseddiagrams do not need to be explicitly parameterized. Instead of loops, Apparatus uses spreads which allow any value to exist in a "superposition". This allows shapes to belooped over implicitly. By decomposing shapes into paths of points, it also enables Apparatus to plot curves.

Toby Schachman - Communications Design Group

Toby Schachman is an artist and interaction designer interested in new ways of seeing. He currently is a researcher in the Communications Design Group working onalternative interfaces for programming. He holds a master's degree from the Interactive Telecommunications Program at NYU and a bachelor's degree from MIT. He is aprevious Eyebeam fellow.

A Live Programming Experience

Date: 2015-09-24 15:50Room: Grand DEFFormat: future of programming

Track: fpw

Live programming provides live feedback about how code executes while it is being edited. Unfortunately, live programming and similar efforts are still not very wellunderstood with many attempts limited to demo-ware, fancier LISP-like REPLs, or Smalltalk-like fix-and-continue IDEs, which while useful, lack true live feedback. Thisessay presents a new live programming experience called APX (A Programming eXperience, a play on Iverson's APL) that aims to overcome these challenges with alanguage, type system, rich code editor, and virtual time machine designed for useful live feedback. We frame our discussion of live programming design and technologychallenges in a description of APX.

Sean McDirmid - Microsoft Research

Sean is an American refugee currently living in Beijing. There, he works for Microsoft exploring how programming experiences can be re-invented and significantlyimproved by considering them holistically (e.g. via live programming) rather than the typical piecemeal approach that considers language and tooling separately. Beforebeing exiled, he obtained a PhD from the U of Utah with a post doc at EPFL working on Scala.

Ceptre: A Language for Modeling Generative Interactive Systems

Date: 2015-09-24 16:40Room: Grand DEFFormat: future of programmingTrack: fpw

TBD

Chris Martens - CMU

Workshops

Sonic Pi Live Coding

Date: 2015-09-24 09:00Room: Frisco BurlingtonFormat: workshopTrack: languages

Unleash your inner creative programming potential using Sonic Pi in this live coding workshop. Sonic Pi is a free live coding music synth designed to be simple enoughfor anybody to use yet powerful enough for serious performances.

We'll explore the basics of live coding with Sonic Pi - triggering synths and samples, studio FX and live loops. No prior knowledge of coding or music is required.However if you do have experience you'll be able to instantly use this to good effect. Sonic Pi is as much a tool for professional programmers and musicians as it is for 10year old children and curious technophobes.

Together we'll learn, jam, explore, share and perform with each other all through the beautiful creative medium of code.

To attend the workshop, please bring along a laptop and some headphones. You might want to install and play around with Sonic Pi beforehand (http://sonic-pi.net).However, we will provide USB sticks with the latest version of the app for Macs, Windows and Raspberry Pi computers.

Sam Aaron (@samaaron) - The University of Cambridge

Sam is a live coder who strongly believes in the importance of emphasising, exploring and celebrating creativity within all aspects of programming. He is the leaddeveloper of Overtone and the creator of Sonic Pi, a music live coding environment used to teach programming within schools. By day Sam is a Postdoc ResearchAssociate at the University of Cambridge Computer Laboratory and by night he codes music for people to dance to.

Rethink your database with RethinkDB

Date: 2015-09-24 09:00Room: Illinois CentralFormat: workshopTrack: data

Modern apps require sending data directly to the client in realtime. Web browsers support this via WebSockets, but adapting database systems still presents a hugeengineering challenge. RethinkDB is an open source database for the realtime web. It has an exciting new access model -- instead of polling, the developer can tellRethinkDB to push updated query results to applications in realtime.

We'll explain why the push functionality is a start of a new database access model, and how it eliminates many complex steps necessary for building realtime apps today.Attendees will learn how to build and scale realtime apps with very little code, and with minimal time and effort.

Join RethinkDB founder Slava Akhmechet and Daniel Miller as they demo RethinkDB features and answer your questions in an interactive workshop session.

Daniel Miller - RethinkDB

Daniel Alan Miller is a resident Developer Evangelist with RethinkDB. Having tried to build realtime applications in the past, he was drawn to RethinkDB's change feedslike a moth to a bug zapper. While technology is always cool, building stuff for people is even cooler. Daniel hopes to help everyone do just that with RethinkDB. Heloves gelato :ice_cream: and one day hopes to deliver it in realtime to everyone everywhere.

Slava Akhmechet (@spakhm) - RethinkDB

Slava Akhmechet is the founder of RethinkDB, a database company dedicated to helping developers build realtime web applications. Prior to RethinkDB he was a systemsengineer in the financial industry, working on scaling custom database systems. Slava is a frequent speaker and a blogger. He blogs about his interests in open source,developer tools, building delightful user experiences, and distributed systems on defmacro.org. He is currently on leave from a Ph.D. program in Computational

Neuroscience at Stony Brook University.

An Introduction to Unikernels with the HaLVM

Date: 2015-09-24 09:00Room: JeffersonianFormat: workshopTrack: tools

Unikernels, or library operating systems, offer a new method for building and managing lightweight services in the cloud. Instead of building a service on an operatingsystem, unikernels compile the core operating system components they need into a single binary bundle. Unlike systems like Docker, these bundles then run directly onXen, instead of running as a protected process under Linux. This makes them extremely lightweight and flexible, as they only need to include the operating systemservices they absolutely require. In addition, they can provide better security than traditional systems, including Docker, as they contain less code to exploit and are, bydefinition, highly diverse.

There are a growing number of unikernel development systems out there, each for a different language: Rump Kernels or OSv for C, Mirage for OCaml, etc. In thisworkshop, we will introduce attendees to the open source Haskell Lightweight Virtual Machine (HaLVM). Using a high-level language like Haskell with unikernels bringsgreat benefits: abstraction allows us to build significant services quickly, and the language's type system gives us the safety to program with confidence in an austereenvironment. Imagine finding that your low-level service contains an unsafe cast of a 32-bit to 64-bit number at compile time, instead of as a random crash duringexecution!

To help get started quickly, we'll provide a development environment ahead of the workshop in the form of a virtual machine image, give a brief overview of Haskellfundamentals, and then get down to business. After a couple finger exercises to understand the basics of unikernel development and debugging, we'll jump into buildingweb services with the HaLVM. You'll see how small web services running on the HaLVM can be, while still providing useful services. We'll develop, deploy, and testthem on our virtual machines. Those with Amazon EC2 accounts will then be able to upload their unikernels and run them on Amazon's cloud.

Adam Wick (@acwpdx) - Galois, Inc.

Dr. Adam Wick leads Galois's systems software and mobile security team, and was the creator of the HaLVM. In his current role, he has led projects that have used theHaLVM for communications and network security tasks, and has given talks at several Xen Summits as well as QCon SF about this work. Beyond the HaLVM, Adam hasled Galois's investigations into secure operating system design, trustworthy mobile roots of trust, and predictive security for UAVs. Before Galois, Adam received hisPh.D. from the University of Utah, and his B.S from Indiana University.

Trevor Elliott (@moltarx) - Galois, Inc.

Trevor Elliott is an engineer at Galois, and the designer and implementer of the Haskell Network Stack (HaNS). Trevor has extensive experience with the HaLVM, havingused it in several engineering efforts at Galois. In addition, Trevor has worked on a wide variety of projects at Galois, including efforts in compiler design, cryptography,network security, and web system design. Trevor earned his B.S. in Computer Science from Portland State University in 2008.

Adam Foltzer (@acfoltzer) - Galois, Inc.

Adam Foltzer is a research engineer at Galois, and a member of the Haskell.org Committee. Adam was lucky enough to begin programming in Scheme when he was quiteyoung, and has since then had a passion for functional and denotational programming. While getting a B.S. and M.S. in Computer Science from Indiana University, hebegan using Haskell while studying the theory, design, and implementation of programming languages; parallel and concurrent programming; and quantum and reversiblecomputing. Prior to studying Computer Science, he studied Russian language and literature, archaeology, and how to fly small aircraft.

Stepping Outside Your Comfort Zone: Learning to Teach

Date: 2015-09-24 09:00Room: Missouri PacificFormat: workshopTrack: etc

As a developer you spend your entire life learning. But what happens when the tables are turned and you become the teacher? Do you want to become a conferencespeaker, talk at your local user group, be a mentor, give presentations at work, or become a technical trainer? As a previous classroom teacher with a Master's Degree inCurriculum Development, I will take you on a journey to understand the various learning styles and how to effectively reach everyone. We will look at how to presentyour information, best ways to structure it, and learn ways to reach all students no matter their level. We will also cover a number of best practices for crafting yourpresentation decks themselves. Join me for this exploration into the inner workings of the human mind.

Heather White (@CattyCreations) - php[architect]

Heather has held various jobs in the past, ranging from teaching elementary school to being a project manager and trainer for the Army's medical researchprogram.  She holds a Bachelors of Biology and a Masters in Curriculum Development.  Currently she uses her background in curriculum and teaching to head upthe Training Program at php[architect], as well as being their customer service lead. Heather is also a self proclaimed geek and enjoys Sci-Fi, Medieval reenactment, andboard games.

Idris: Practical Software Verification with Dependent Types

Date: 2015-09-24 09:00Room: New York CentralFormat: workshopTrack: languages

Idris is a general purpose functional programming language with full dependent types, building on state-of-the-art techniques in programming language research.Dependent types allow types to be predicated on any value - in this way, required properties of a program can be captured in the type system, and verified by a typechecker. This includes functional properties (i.e. does the program give the correct answer) and extra-functional properties (i.e. does the program run within specifiedresource constraints).

Idris aims to bring type-based program verification techniques to programming practitioners while supporting efficient systems programming via an optimising compiler

and interaction with external libraries.

In this workshop, I will use a series of examples to show how dependent types may be used for verifying realistic and important properties of software, from simpleproperties such as array bounds verification, to more complex properties of communicating and distributed systems.

The main objective of the workshop is to give an overview of what is expressible in modern, state-of-the-art, type systems, and to give participants some introductoryexperience with the Idris programming language. It will be interactive, and participants will get hands-on experience with Idris.

The workshop will explain why software correctness, particularly extra-functional correctness, is important, and show how Idris' dependent type system can support this. Itwill cover:

Getting started: compiling and running programsSimple functional properties of listsExtra-functional properties including side-effects and resource usage protocolsA concluding example: using the type system to reason about communicating systems

By the end of the workshop, participants will understand how to express invariants in a dependent type system, how to write programs which respect those invariants, andhow to use embedded domain specific languages as an abstraction layer over those invariants to reduce or even eliminate the verification burden on application developers.

Code for the examples will be made available, along with accompanying exercises.

Edwin Brady (@edwinbrady) - University of St Andrews

Edwin Brady is a Lecturer in Computer Science at the University of St Andrews in Scotland, UK. His research interests there include programming language design, inparticular type systems and domain specific languages. Since 2008, he has been designing and implementing the Idris programming language, a general purpose functionalprogramming language with dependent types, which he uses to implement verified domain specific languages. When he's not doing that, he's likely to be playing a gameof Go, wrestling with the crossword, or stuck on a train somewhere in Britain.

Building a Dynamic Security Response Environment

Date: 2015-09-24 12:30Room: Frisco BurlingtonFormat: workshopTrack: security

As we expand our technological footprint, our environment grows. Our risk grows with it. While we have made advancements in dynamic environments we have donelittle in the security space. Threats come and go, and our ability to quickly respond to the situation is lackluster at best. We block attackers by updating block lists andrunning deployment scripts. This takes time and can lead to availability issues.

Join Aaron as he walks through creating an environment that can quickly respond to web based threats as they appear. You will walk away with the ability to respond tomalicious actors in near real time with no configuration updates or deployment scripts. You will also learn some tricks for identifying malicious actors and stopping thembefore they become a problem.

Aaron Bedra (@abedra) - Groupon

Aaron is a Principal Engineer at Groupon. He is the creator of Repsheet, an open source threat intelligence framework. He is the co-author of Programming Clojure, 2ndEdition and a frequent open source contributor.

Build your own Distributed Framework on Mesos using Clojure

Date: 2015-09-24 12:30Room: Illinois CentralFormat: workshopTrack: distributed-systems

Building a fast, reliable distributed system that provides maximum utilization of computing resources involves careful understanding of scheduler behavior, fault-tolerancetradeoffs, and when and where jobs are supposed to be run. Thankfully, this has become easier to understand with the introduction of Mesos in the data center. MultipleMesos frameworks, which handle the scheduling and execution of application tasks, can run on the same cluster to get the fullest utilization of hardware, and in manycases decide where an application should run for lowest latency and highest reliability. This workshop aims to demystify the process of writing a Mesos framework andshow how it helps handle problems faced by distributed systems engineers. Clojure is used as a way to understand and interactively build the system. A system designercan apply knowledge gained to other languages depending on their requirements.

Ed Paget (@edpaget) - Zooniverse

Ed Paget is a software developer with the Zooniverse where he writes software that allows scientists and volunteers to collaborate on scientific research. He's interested inhow small teams can use Mesos to simplify how they manage their infrastructure. When he's not helping find supernovae or count wildebeests, Ed enjoys playingbasketball, drinking coffee, and hacking on Emacs.

Prasanna Gautam (@prasincs) - Staples SparX

Prasanna works as a Software Engineer at Staples SparX. He has had experience in building and managing various types of distributed systems - from systems to schedulejobs for scientific computing to building small clusters on Raspberry Pis. He fell in love with Clojure in his college years and has been building systems in the languageever. He sees a lot of potential in the power of Clojure and Mesos for simplifying the development and management of large scale distributed systems.

Taking Off with Phoenix

Date: 2015-09-24 12:30Room: JeffersonianFormat: workshop

Track: web

Phoenix is an Elixir framework for building scalable web applications with realtime connectivity across all your devices. Together, we'll take a guided tour of theframework, going from the very basics, to building our own realtime applications. You'll see the framework's foundations, core components, and how to use Phoenix towrite powerful web services.

Sonny Scroggin (@scrogson) - Blue Box, Inc.

Sonny Scroggin is a software craftsman with broad interests in the world of computing. He is a core team member of the Phoenix Framework and is working on variouslibraries within the Elixir ecosystem. You can find him presenting or teaching others about Elixir, Phoenix, and other tools and libraries in the local user groups inNashville, TN.

Understanding Latency & Application Responsiveness

Date: 2015-09-24 12:30Room: Midway IFormat: workshopTrack: languages

Managing, monitoring, and improving application responsiveness is a common need for many software professionals. Whether you develop applications or manage them,understanding application responsiveness and the major mechanisms that affect it is key to achieving successful applications and happy users. In this session, Gil Tene willprovide an in-depth overview of Latency and Response Time Characterization, including proven methodologies for measuring, reporting, and investigating latencies, andan overview of some common pitfalls encountered (far too often) in the field.

Gil Tene (@giltene) - Azul Systems

Gil Tene is CTO and co-founder of Azul Systems. He has been involved with virtual machine and runtime technologies for the past 25 years. His pet focus areas includesystem responsiveness and latency behavior. Gil is a frequent speaker at technology conferences worldwide, and an official JavaOne Rock Star. He pioneered theContinuously Concurrent Compacting Collector (C4) that powers Azul's continuously reactive Java platforms. In past lives, he also designed and built operating systems,network switches, firewalls, and laser based mosquito interception systems.

Programming with Refinement Types

Date: 2015-09-24 12:30Room: Missouri PacificFormat: workshopTrack: tools

Haskell has many delightful features, perhaps the most beloved of which is its type system which allows developers to specify and verify a variety of program properties atcompile time. However, many properties, typically those that depend on relationships between program values are impossible, or at the very least, cumbersome to encodewithin Haskell's type system.

Refinement types enable the specification and verification of value-dependent properties by extending Haskell's type system with logical predicates drawn from efficientlydecidable logics.

In this workshop, we will start with a high level description of Refinement Types. Next, we will present an overview of LiquidHaskell, a refinement type checker forHaskell. In particular, we will describe the kinds of properties that can be checked, ranging from generic requirements like like totality (will 'head' crash?) and termination(will 'mergeSort' loop forever?), to application specific concerns like memory safety (will my code SEGFAULT?) and data structure correctness invariants (is this treeBALANCED?).

Joint work with: Niki Vazou, Eric Seidel, Patrick Rondon, Dimitris Vytiniotis and Simon Peyton-Jones.

Ranjit Jhala (@ranjitjhala) - UC San Diego

Ranjit Jhala is a Professor of Computer Science and Engineering at the University of California, San Diego. He is interested in building algorithms and tools that helpengineer reliable computer systems. His work draws from and contributes to the areas of Model Checking, Program Analysis, and Automated Deduction, and TypeSystems. He has helped create several influential systems including the BLAST software model checker, RELAY race detector, MACE/MC distributed language andmodel checker, and is now working to sneak formal specification and verification into daily programming, under the disguise of types.

Beginning Onyx - Distributed Computation in Clojure

Date: 2015-09-24 12:30Room: New York CentralFormat: workshopTrack: distributed-systems

Does your application need to manipulate more data than a machine can handle? Have you tried Hadoop, Storm, or Spark but felt it didn't quite fit your problem?

Onyx is a new distributed, masterless, fault tolerant computation platform written specifically with Clojure developers in mind. Onyx gracefully composes many concernsthat other frameworks complect: computational structure, data flow, lifecycles, deployment, and more. Its superpower is its ability to create distributed workflows atruntime in an ad-hoc fashion. In effect, Onyx allows you to bridge the gap across programming languages, execution environments, and machines. Nothing is fixed atcompile time, offering you near infinite flexibility compared to its competitors.

This workshop will begin with an overview of Onyx's design, information model, and usage patterns. We'll put our new-found knowledge to work and develop a sampleanalytics application that exercises each of Onyx's core features. After this workshop, attendees will feel comfortable writing and deploying Onyx programs to the cloud tocombat their data-driven problems.

In order to complete this workshop, you'll need an intermediate amount of Clojure experience and a working installation of Leiningen.

Michael Drogalis (@MichaelDrogalis) - ViaSat

Michael Drogalis a software engineer at ViaSat and the creator of Onyx. By day, he works on private cloud infrastructure to support satellite operations. By night, hehacks the Onyx platform - moving Clojure to the forefront of the distributed computation universe.

Lucas Bradstreet (@ghaz) - Independent Consultant

Lucas Bradstreet is a core contributor to Onyx. In a previous life he worked in analytics for Oil and Gas and performed research into evolutionary algorithms.

Build Haskell Web Services!

Date: 2015-09-24 15:00Room: Frisco BurlingtonFormat: workshopTrack: web

Haskell is an interesting language with a lot of literature. If you want to learn about the type system, the compiler, category theory, parsing, error-handling strategies,representing JSON and other little languages - great! But, what if you wanted to build an application? There's a scarcity of resources that guide you through the process ofcreating a full Haskell application. Putting together all the pieces can be daunting!

This workshop aims to address that problem.

In two hours, we'll walk through the process of building a simple HTTP/JSON API in Haskell while leveraging several great libraries. We'll walk through the initialproject setup, dependency management, directory structuring, JSON [en|de]coding, endpoint registration, logging, and ad-hoc testing.

This workshop assumes that:

You've used Haskell before, to the extent of having completed the first 8 weeks of CIS194: http://www.seas.upenn.edu/~cis194/lectures.htmlYou're familiar with HTTPYou're familiar with JSONYou're comfortable with a command line interface

If you're not comfortable with Functor/Monad/Applicative and related abstractions, that's okay! If you're still getting used to Haskell's type systems, that's okay, too! We'llmake use of them in fairly simple ways, and I'll explain as we go. They'll be far from the focus of this talk.

All code used in this workshop will be made available in a git repository, along with instructions to set up the workshop development environment on Linux, Mac OS X,and Windows.

Alej Cabrera (@queertypes) - Eduphoria

Alej Cabrera is a software developer with an interest in programming languages, type theory, social structures, and Haskell. By day, they help write backend services inHaskell for Eduphoria. By night, they'll read research papers, enjoy a great deal of laziness, and make sure the cats are happy and fed. They listen to chiptune and love 4-arrow dance games.

Advanced Docker concepts and container orchestration

Date: 2015-09-24 15:00Room: Illinois CentralFormat: workshopTrack: distributed-systems

You have installed Docker, you know how to run containers, and have written Dockerfiles to build container images for your applications (or parts of your applications).Now what?

Now comes the next part: connecting multiple containers together, and deploying them on a cluster of Docker hosts, instead of your single development machine.

This is what we want to cover here, alongside with some production-related questions: how to manage logs? Backups? Remote access? Security upgrades?

In this workshop, we will present the networking model of containers, and how to run containerized applications spanning multiple Docker hosts. We will give recipes toimplement cleanly ops tasks like logging, backups, and more. Finally, we will discuss orchestration and scheduling. We will present solutions like Swarm and Mesos, andsee some of them in action on an actual microservices architecture.

You won't need to pre-install Docker before the course: each student will be given credentials to connect to an individual virtual machine. So all you need is a computerwith a SSH client!

Jerome Petazzoni (@jpetazzo) - Docker Inc.

Jerome is a senior engineer at Docker, where he helps others to containerize all the things. In another life he built and operated Xen clouds when EC2 was just the name ofa plane, developed a GIS to deploy fiber interconnects through the French subway, managed commando deployments of large-scale video streaming systems inbandwidth-constrained environments such as conference centers, operated and scaled the dotCloud PAAS, and various other feats of technical wizardry. When annoyed,he threatens to replace things with a very small shell script.

AJ Bowen (@s0ulshake) - Gandi.net

AJ does technical community outreach as chief of counter-bullshit operations at Gandi.net, a domain name registrar, webhost and SSL provider that sets respect forcustomer rights, internet freedom and open source as its top priorities.

Their life mission is to do away with unnecessary hierarchy, yak-shaving bikeshedders and gendered pronouns.

Hands-on Functional Swift

Date: 2015-09-24 15:00Room: JeffersonianFormat: workshopTrack: languages

This workshop will be a hands-on live coding introduction to Apple's Swift programming language with emphasis on the functional aspects. Attendees will bring theirMac laptops with Apple's Xcode IDE pre-installed and will follow along with the exploration of the language's support of first-class functions and their composition intohigher-order functions, immutable value types and their implementation in the form of the standard library's base collection type, and Swift's unique convenience pseudo-mutator syntax that makes copy-changes possible without the need to any sort of lens library.

Marc Prud'hommeaux - Glimpse I/O

Marc Prud'hommeaux is the indie developer at glimpse.io, making enterprise database and data visualization apps for iOS and the Mac. After a mis-spent youth writingenterprise software in C and Java, he has since 2006 been developing Cocoa apps in Objective-C and was the author of the first e-book reader in the app store: Stanza. Hehas helped develop apps for Amazon, the New York Times, Oracle, and other large organizations. Marc has been writing software for over 30 years and has given talks,presentations, and trainings in a dozen countries.

Practical Property Testing for Services

Date: 2015-09-24 15:00Room: Missouri PacificFormat: workshopTrack: etc

When we test at the API level, we say "no" to unwanted changes and "yes" to refactoring freedom. At service boundaries, tests express system invariants and expectationsthat your services will meet. They don't constrain the implementation.

Why don't we do all our testing here? Perhaps because there are so many possible test cases, edge cases and possible combinations of features we could never cover themall.

Property testing solves that. In a property-based test, code generates those test cases, looks for violated expectations, then narrows input to the simplest test case that fails.The Scala compiler uses this kind of testing, and your business software can too.

The most difficult part of property-based testing is conceiving the properties. This workshop will show several techniques for finding and creating properties. In the hands-on practice, we will:

create and compose Generators to produce input datawrite and combine Properties to check test resultsconstruct Shrinkers to simplify the failing test casestune test output for easier troubleshooting.

Property-based testing is hard -- and that's the best part. Compared to unit tests, property testing pushes us to think more about the overall purpose of our code. Come tothis workshop, and get the background you need to push yourself and your tests to a stronger level.

Exercises and demos will be in Scala; the techniques apply in other languages as well.

Jessica Kerr (@jessitron) - Monsanto

Jessica Kerr is a functional developer on the JVM, in Scala and Clojure. She speaks at conferences about functional programming, property-based testing, and other waysto make development more joyful. She takes community involvement seriously: you can tell, because she has a tattoo of her twitter handle. Currently she's working onScala microservice cloud infrastructure at Monsanto, and keeping two gradeschool daughters alive and wacky. Find her work on her blog (Abstractivate), at Pluralsight,and scattered across the internet.

Real-World Angular: Large, Fast, and Sane

Date: 2015-09-24 15:00Room: New York CentralFormat: workshopTrack: web

Angular has exploded in popularity over the last few years, and for good reason. It provides a very different, and very appealing, approach to building web applicationsthan that of most other frameworks, and it's surprisingly easy to build a real, working application with very little code.

Unfortunately, it's just as easy to get stuck as it is to get started. Angular is powerful, yes, but the learning curve is steep, and while it makes easy things very easy,progress beyond that early rush of success can be tough. Many developers find themselves, a few weeks (or even months) into their first significant Angular project,wondering how things got so out of hand.

This workshop will fix that. We'll start with an overview that puts all the major pieces of Angular in context, and explains their purpose and intent. From there, we'll diveinto specific tools and techniques to help you build Angular applications that are maintainable, performant, and scalable.

Specifically, we'll talk about these topics from a distinctly Angular perspective:

Architecture, layout, and file structure of large applicationsWhat goes where, and why -- routing, services, directives, and morePerformance considerationsUnit and scenario testing strategiesWorkflows, tooling, and automationFuture-proofing and migration (a.k.a., preparing for the inevitable)Real-world style guidelines and best practices

In short, we'll cover what it takes to build large Angular applications that are fast and robust, without losing the power and flexibility that Angular provides.

Bill Odom (@wnodom)

Bill Odom has been a software designer, developer, or systems architect for over two decades. For the last several years, he's served as a consultant, trainer, and seniorsoftware developer for organizations large and small all across the US. He's been building web applications across a variety of platforms, tools, and technologies since theearliest days of the web. He's spent much of the last couple of years as an instructor for Oasis Digital's Angular Bootcamp (http://angularbootcamp.com), teaching teams ofdevelopers how to build large Angular applications.

Matt Follett (@mfollett)

Matt Follett has been a software engineer or software architect for the better part of a decade. During that time he has helped solve a variety of problems related to genomesequencing, drunk driving, and network modeling and security. Lately, he spends his free time jumping between embedded systems development and web development.

Friday, Sept 25thI See What You Mean

Date: 2015-09-25 09:10Room: TheaterFormat: keynoteTrack: keynote

I love query languages for many reasons, but mostly because of their semantics. Wait, come back! In contrast to most systems programming languages (whose semanticscan be quite esoteric), the semantics of a query (given some inputs) are precisely its outcome -- rows in tables. Hence when we write a query, we directly engage with itssemantics: we simply say what we mean. This makes it easy and natural to reason about whether our queries are correct: that is, whether they mean what we intended themto mean.

Query languages have traditionally been applied to a relatively narrow domains: historically, data at rest in data stores; more recently, data in motion through continuous,"streaming" query frameworks. Why stop here? Could query languages do for a notoriously complex domain such as distributed systems programming what they havedone so successfully for data management? How would they need to evolve to become expressive enough to capture the programs that we need to write, while retaining asimple enough semantics to allow mere mortals to reason about their correctness?

I will attempt to answer these questions (and raise many others) by describing a query language for distributed programming called Dedalus. Like traditional querylanguages, Dedalus abstracts away many of the details we typically associate with programming, making data and time first-class citizens and relegating computation to asubordinate role, characterizing how data is allowed to change as it moves through space and time. As we will see, this shift allows programmers to directly reason aboutdistributed correctness properties such as consistency and fault-tolerance, and lays the foundations for powerful program analysis and repair tools (such as Blazes andLDFI), as well as successive generations of data-centric programming languages (including Bloom, Edelweiss and Eve).

Peter Alvaro (@palvaro) - University of California Santa Cruz

Peter Alvaro is an Assistant Professor of Computer Science at the University of California Santa Cruz. His research focuses on using data-centric languages and analysistechniques to build and reason about data-intensive distributed systems, in order to make them scalable, predictable and robust to the failures and nondeterminism endemicto large-scale distribution. Peter is the creator of the Dedalus language and co-creator of the Bloom language.

While pursuing his PhD at while UC Berkeley, Peter co-developed and taught Programming the Cloud, an undergraduate course that explored distributed systemsconcepts through the lens of software development. Prior to attending Berkeley, Peter worked as a Senior Software Engineer in the data analytics team at Ask.com. Peter'sprincipal research interests are databases, distributed systems and programming languages.

Safe and fast parsers with Nom and Rust

Date: 2015-09-25 10:10Room: CenteneFormat: talkTrack: security

Parsing is hard. It is the cause of hundreds of vulnerabilities, implementation mistakes and plain crashes in production. It got easier with techniques like parsercombinators, but developers did not adopt them right away, especially in binary formats for low level contexts, like C development. Most solutions were deemed eitherslow or memory hungry, for right and wrong reasons.

The Rust language, developed by Mozilla, came with promises of safe, low level data manipulation, with efficient memory usage. The Nom parser combinators librarywas designed to check that assertion and verify that safe, zero copy, streaming parsers were a practical approach. Its development put light on an essential factor ofadoption for parsing solutions: the usability and tooling are crucial.

This talk will cover the tricks provided by Rust to manage memory efficiently, its safety net for developers, and its ability to integrate with C code. Then we will approachthe interaction between language theory and classical file format (best or worst) practices. I will also present the tools I wrote to make the programmer's life easy duringdesign, development, debugging and production.

Geoffroy Couprie (@gcouprie) - Clever Cloud

Geoffroy handles security and quality assurance at Clever Cloud, develops in Rust and researches on parser security at VideoLAN. He thinks a lot about cryptography,protocol design and data management.

How to Have your Causality and Wall Clocks, Too

Date: 2015-09-25 10:10Room: Midland States BankFormat: talkTrack: distributed-systems

Does it bother you when all your microservice logs show up out of order in your log analysis tool because your system clocks aren't synchronized? Did you ever wonderwhat time it was when the dotted version vector on a piece of data became 2.4.5? If so, then this is the talk for you!

Time is a notoriously difficult concept in distributed systems. Perfect clock synchronization is impossible, and most logical timestamp schemes (like Lamport clocks) don'tbear a relationship to "wall clock time" that is meaningful to human operators.

In this talk, we'll learn about distributed monotonic clocks (DMC) whose timestamps can reflect causality but which have a component that stays close to wall clock time.This scheme builds on previous hybrid logical clock proposals by adding important operational hooks and by building in mechanisms to prevent a single runaway systemclock from dragging a whole cluster's logical clocks forward into the future.

DMCs can be implemented as a "piggyback protocol" suitable for transport in existing application messages--for example, as additional HTTP headers. I'll describe anovel coordination protocol in this unusual piggyback style--a style that may also be useful in ad-hoc clusters formed by Internet-attached "things".

Jon Moore (@jon_moore) - Comcast

Jon Moore is a Senior Fellow at Comcast Cable, where he leads the Core Application Platforms group that focuses on building scalable, performant, robust softwarecomponents for the company's varied software product development groups. His current interests include distributed systems, hypermedia APIs, and fault tolerance. Jonreceived his Ph.D. in Computer and Information Science from the University of Pennsylvania and currently resides in West Philadelphia.

Teaching Kids Programming at the IOT Farm

Date: 2015-09-25 10:10Room: Peabody LoungeFormat: talkTrack: etc

While kids are experts at consuming technology, very few participate in technology creation. With so many countries, including our own, now considering ComputerScience a vital part of core education, what are the best practices to use with kids in the classroom? Using several different delivery platforms including camps, Teen UserGroups and traditional classrooms, come learn how to teach computer programming using pair programming, mob programming and other techniques designed to delivercomputer programming in a social, collaborative environment rather than the headphones and isolated method.

Come learn how to turn a kitchen, a farm, a conference room into a tech classroom that inspires teens to see technology as the answer to many of their real world concerns.Our Teen User Group, which is 75% girls and has maintained 100% retention, has chosen to take on water conversation by implementing IOT devices into a small urbanfarm and have the data collected tweeted by their Tweeting Windmill.

Jessica Ellis (@jellis_tkp) - Teaching Kids Programming

Jessica is the Project Manager for Teaching Kids Programming. She is also the Director for the Center for a Healthy Lifestyle, a project of the Boys and Girls Clubs of SanDieguito.

Jesse Phelps (@jessephelps) - POMIET

Jesse is a Software Developer for POMIET and an entrepreneur. Jesse is technologically agnostic and dabbles in all aspects of technology from writing software tobuilding/hacking hardware. When not immersed in technology, Jesse spends his free time with his wife Sarah and sons, Jonah and Jackson. He also enjoys brewing beer,politics and theology.

Managing Containers at Scale with CoreOS and Kubernetes

Date: 2015-09-25 10:10Room: Pepsi EncoreFormat: talkTrack: distributed-systems

The last decade belonged to virtual machines and the next one belongs to containers.

Virtualization lead to an explosion in the number of machines in our infrastructure and we were all caught off guard. It turns out that those shell scripts did not scale afterall. Lucky for us configuration management swooped in to save the day.

But a new challenge is on the horizon. We are moving away from node-based infrastructures where hostnames are chosen with care. Gone are the days of pinning oneservice to a specific host and wearing a pager in case that host goes down.

Containers enable a service to run on any host at any time. Traditional tools are starting to show cracks because they were not designed for this level of applicationportability. Now is the time to look at new ways to deploy and manage applications at scale.

Linux containers provide the ability to reliably deploy thousands of application instances in seconds. And we can manage it all with CoreOS and Kubernetes. This talk willhelp attendees wrap their minds around complex topics such as distributed configuration management, service discovery, and application scheduling at scale. It willdiscuss CoreOS, a Linux distribution designed specifically for application containers and running them at scale. It will examine all the major components of CoreOSincluding etcd, fleet, docker, and systemd; and how these components work together with Kubernetes to solve the problems of today and tomorrow.

Kelsey Hightower (@kelseyhightower) - CoreOS

Kelsey Hightower is product manager, developer and chief advocate at CoreOS

Kelsey has worn every hat possible throughout his career in tech and enjoys leadership roles focused on making things happen and shipping software.

Kelsey is a strong open source advocate focused on building simple tools that make people smile. When he is not slinging Go code you can catch him giving technicalworkshops covering everything from Programming, System Administration, and his favorite Linux distro (CoreOS).

Unconventional Programming with Chemical Computing

Date: 2015-09-25 10:10Room: TheaterFormat: talkTrack: etc

Take a step back from your normal programming approach and discover a new way of looking at problems. All living organisms information systems are based onchemical processes. What can we learn by using this metaphor of chemistry in our programming? We will answer this question by looking at Artificial ChemicalComputing. Building programs based on molecules and chemical reactions, we will explore new ways of thinking and opening ourselves up to innovation. We will discussthe basics of Chemical Programming and even touch on High Order Chemical Programming as well. Code examples will be in the powerful, elegant, and interactiveprogramming language of Clojure, but you will not need to be an expert in the language to enjoy the demos. Come and join us for this adventure in looking at theprogramming world from a different perspective.

Carin Meier (@gigasquid) - Cognitect

Carin started off as a professional ballet dancer, studied Physics in college, and has been developing software for both the enterprise and entrepreneur ever since. She has astrong background in Ruby and Clojure. Her passions lead her to the intersection of the physical and digital world, combining hardware and software, where she hashelped clients develop Home Automation Systems as well as written a control library for the Parrot AR Drone in Clojure. She is highly involved in the community andspoken at many conferences, including keynoting at OSCON and Strange Loop. She helps lead the Cincinnati Functional Programmers and is the author of "LivingClojure".

Immutable Data Science with Datomic, Spark and Kafka

Date: 2015-09-25 11:00Room: CenteneFormat: talkTrack: architecture

We would like to present our company's approach to data science architecture, which is novel in its use of the Datomic database (in a microservices architecture) and theintegration of Datomic with Spark. We leverage several unique properties of Datomic, Spark, and Kafka to achieve scalable real time analysis against production datawithout resorting to traditional ETL techniques:

Immutability and consistent timeline: machine learning models in a microservice architecture with full traceability without copying dataMulti-database querying: a fresh approach to OLAP that is both unified with and isolated from production OLTP services, and enables read auditing and granularaccess control for exploratory use cases without performance impact in productionModern stored procedures: a fresh take on exposing domain logic functions (e.g., canonical financial calculations in service code, under source control), to multi-database Datomic queries, enabling consistent definitions for data scientists and engineersPass-by-reference queries: allow saving and sharing of data via immutable saved queries, which will never change for a given "as-of" timestamp, as well aspersistent materialized views (Spark RDDs) stored in cluster memory or encrypted S3Horizontal read scalability: parallel queries of live production data, and downstream transformation and analysis, sharded across an arbitrarily large Spark cluster(moving the code to the data)Immutable messaging substrate: Kafka supports real time Spark streaming use cases in addition to exploratory batch functionality

This architecture is an alternative to the popular "lambda" and "kappa" architectures, and will be of primary interest to architects looking for innovation in moderntechnologies, engineers interested in Clojure, Datomic and Datalog, modelers hungry for data, and analysts making data-based decisions. In addition, we work withsensitive personal information that remains encrypted at rest, making our solution relevant for those interested in information security.

In summary, this solution has allowed us to avoid ETL / database synchronization pipelines while preserving scalability and isolation of transactional and analytical usecases.

Konrad Scorciapino (@konr) - Nubank

Konrad Scorciapino is a data architecture engineer at Nubank. It was love at first sight with parentheses and his beautiful wife. He organizes the "Clojure São Paulo" and"Machine Learning São Paulo" user groups and his 2015 year resolution is to read 60 books (40 to go!)

Mauro Lopes (@maurolopes23) - Nubank

Mauro is a data architecture engineer at Nubank. He holds a Master's degree in Graph Theory, plays badminton and has Erdős number 3.

Faster Objects and Arrays

Date: 2015-09-25 11:00Room: Midland States BankFormat: talkTrack: languages

This session introduces org.ObjectLayout and StructuredArray, a new Java collection library and an array class designed specifically to enable JVMs to optimize memorylayout for arrays of objects in a way that closely matches the performance behaviours of arrays of structs in C. org.ObjectLayout works on any JDK (version 6.0 andabove), but when "intrinsified" in newer JDKs, it brings dead-reckoning and streaming speed to what is in essence an array of Java objects.

The presentation covers the APIs and design considerations behind them and explains the fundamentals behind logic that can allow Java JDKs to match C on datastructure access speeds.

Gil Tene (@giltene) - Azul Systems

Gil Tene is CTO and co-founder of Azul Systems. He has been involved with virtual machine and runtime technologies for the past 25 years. His pet focus areas includesystem responsiveness and latency behavior. Gil is a frequent speaker at technology conferences worldwide, and an official JavaOne Rock Star. He pioneered theContinuously Concurrent Compacting Collector (C4) that powers Azul's continuously reactive Java platforms. In past lives, he also designed and built operating systems,network switches, firewalls, and laser based mosquito interception systems.

Building Isomorphic Web Applications with React

Date: 2015-09-25 11:00Room: Peabody LoungeFormat: talkTrack: web

Is an isomorphic web app right for you? React and the Virtual DOM make it possible to write code once that will run on the server and the browser. This has manypotential benefits from SEO to performance to code maintainability. We will discuss the benefits and challenges present in building an isomorphic web application. Someof the challenges we will discuss will include how to handle asynchronous data with React's render cycle, synchronizing data and state between the server and browser andknowing when to write browser or server specific code. We will cover how to use React with Node and webpack to solve these problems.

Elyse Kolker Gordon (@ElyseKolker) - VEVO

Elyse Kolker Gordon works as a Web Developer at VEVO working with Angular, React and Node. In her free time she can be found exploring functional programming,taking her dog to the beach and drumming.

How machine learning helps cancer research

Date: 2015-09-25 11:00Room: Pepsi EncoreFormat: talkTrack: data

Machine learning methods are being applied in many different areas - from analyzing financial stock markets to movie recommender engines. But the same methods canbe applied to other areas that also deal with big messy data. In bioinformatics I use similar machine learning, only this time to help find the underlying mechanisms ofcancer.

The problems in bioinformatics might seem opaque and confusing - sequencing, DNA, methylation, ChIP-seq, motifs etc. But underneath, the same algorithms that areused to find groups of customers based on their buying behavior can be used to find subtypes of cancer that respond differently to treatments. Algorithms for text analysiscan be used to find important patterns in DNA strands. And software verification tools can help analyze biological systems.

In this talk, I'll show you the exciting world of machine learning applications in bioinformatics. No knowledge of biology is required, the talk will be mostly in developer-speak.

Evelina Gabasova (@evelgab) - University of Cambridge

Evelina is a machine learning researcher working in bioinformatics, trying to reverse-engineer cancer at University of Cambridge. Her background is mainly in computerscience, statistics and machine learning. Evelina is a big fan of F# and uses it frequently for data manipulation and exploratory analysis in her research. Outside ofacademia, she also speaks at developer conferences and user groups about using F# for data science. She writes a blog at http://www.evelinag.com.

Propositions as Types

Date: 2015-09-25 11:00Room: TheaterFormat: talkTrack: languages

The principle of Propositions as Types links logic to computation. At first sight it appears to be a simple coincidence---almost a pun---but it turns out to be remarkablyrobust, inspiring the design of theorem provers and programming languages, and continuing to influence the forefronts of computing. Propositions as Types has manynames and many origins, and is a notion with depth, breadth, and mystery. Learn why functional programming is (and is not) the universal programming language.

Philip Wadler (@PhilipWadler) - University of Edinburgh

Philip Wadler is Professor of Theoretical Computer Science at the University of Edinburgh. He is an ACM Fellow and a Fellow of the Royal Society of Edinburgh, pastchair of ACM SIGPLAN, past holder of a Royal Society-Wolfson Research Merit Fellowship, and a winner of the POPL Most Influential Paper Award. Previously, heworked or studied at Stanford, Xerox Parc, CMU, Oxford, Chalmers, Glasgow, Bell Labs, and Avaya Labs, and visited as a guest professor in Copenhagen, Sydney, andParis. He has an h-index of 60, with more than 18,000 citations to his work according to Google Scholar. He contributed to the designs of Haskell, Java, and XQuery, andis a co-author of Introduction to Functional Programming (Prentice Hall, 1988), XQuery from the Experts (Addison Wesley, 2004) and Generics and Collections in Java(O'Reilly, 2006). He has delivered invited talks in locations ranging from Aizu to Zurich.

Typed Clojure: From Optional to Gradual Typing

Date: 2015-09-25 12:50Room: CenteneFormat: talkTrack: languages

Optional type systems enable type checking for otherwise untyped languages, but what happens when you need to interact with untyped libraries? In most systems, theuser provides an unchecked annotation which the type system assumes correct. An incorrect annotation then compromises all guarantees of the type system.

Gradual typing addresses this by inserting dynamic checks that protect the static invariants of typed code. In this talk we present extensions to Typed Clojure promoting itfrom an Optional to a Gradual typing system.

Ambrose Bonnaire-Sergeant (@ambrosebs) - Indiana University Bloomington

Ambrose is a Computer Science PhD student at Indiana University Bloomington, working on gradual typing and Typed Clojure.

Visualising program execution

Date: 2015-09-25 12:50Room: Midland States BankFormat: talkTrack: web

We don't see how code executes. We take peeks, using console.logs and breakpoints, but they don't tell the whole story. This talk shows how to take off our blindfolds.

First we briefly look at why seeing how programs execute is important. The prime example is debugging, which programmers spend about half of their time on. Weshow that the right visualisation can dramatically speed up debugging, but also help with other programming tasks.We take a detailed look at generating and visualising execution traces in Javascript. For this we use Esprima and Falafel, to parse Javascript into an abstract syntaxtree, and add instrumentation by transforming this tree. We see how easy it is to do this, even for larger programs.We then look at advanced tricks to scale all this to performance-intensive programs, using games as an example. We will look at well-known techniques from theliterature -- snapshotting and deterministic replay -- which only recently have been brought to the browser.Finally we look at practical tools that implement these techniques, which you can use during your everyday programming.

Jan Paul Posma (@JanPaul123) - Brigade

Jan Paul Posma is a programmer who has been working on code visualisations for jsdares.com. In his day job he works on revitalising our democracy at Brigade, and hasearlier worked on education at Versal, and collaborative knowledge at Factlink and Wikimedia.

Aurelia - the next generation JavaScript framework you will love

Date: 2015-09-25 12:50Room: Peabody LoungeFormat: talkTrack: web

Aurelia is a next generation JavaScript client framework that leverages simple conventions to empower your creativity created by Rob Eisenberg, creator of Durandal, wholeft Angular 2 team to create cleaner and simpler JavaScript framework of tomorrow written in ECMAScript 7!

Jakub Jedryszek (@JakubJedryszek) - Microsoft

I am a Software Engineer at Microsoft. I work on the Azure Portal - one of the biggest Single Page Applications in the World written in TypeScript. I am co-organizer ofdotNetConfPL - online conference for .NET Developers. I have a blog at jj09.net. I started web development over 10 years ago. Before Microsoft, I was working as a WebDeveloper for SMT Software, Division of Communications and Marketing at Kansas State University, and PGS Software. In Grad School I was Research Assistant atSAnToS Lab research group, at Kansas State University. I developed a Model-Driven Development and Verification Approach for Medical Devices.

Strange loops: capturing knots with powerful notations

Date: 2015-09-25 12:50Room: Pepsi EncoreFormat: talkTrack: languages

Mathematician John Conway once boasted that one of his predecessors took six years (!) to enumerate all 54 knots of a certain type, but that his own powerful notation"made this just one afternoon's work."

How did Conway accomplish this feat? and what tradeoffs did he have to make? and what good is knot theory, anyway?

In this talk, I will enumerate all the knots of <= 7 crossings by using notations of two different schools of knot theory: Conway's, and that of his predecessor CliffordDowker. Along the way, we will examine the quality of the notations, and ask how serializing a knot into text allows us to think about it more systematically.

Kay Ye (@hypotext) - Student at Princeton

Kay likes to study weird interdisciplinary things and powerful notations.

When "Worst" is Best (in Distributed Systems)

Date: 2015-09-25 12:50Room: TheaterFormat: talkTrack: distributed-systems

In many areas of systems design, provisioning for worst-case behavior (e.g., load spikes and anomalous user activity) incurs sizable penalties (e.g., performance andoperational overheads) in the typical and best cases. However, in distributed systems, building software that is resilient to worse-case network behavior can -- perhapsparadoxically -- lead to improved behavior in typical and best-case scenarios. That is, systems that don't rely on synchronous communication (or coordination) in the worstcase frequently aren't forced to wait in any case -- improving latency, scalability, and performance via increased concurrency.

In this talk, we'll explore how to use this worst-case analysis as a more general design principle for scalable systems design. As developers increasingly interacting withand building our own distributed systems, we tend to fixate only on failure scenarios (e.g., "partition tolerance" in the CAP Theorem); this is an important first step, but it'snot the whole story. To illustrate why, I'll present practical lessons learned from applying this principle to both web and transaction processing applications as well asdatabase internals such as integrity constraints and indexes. We've found considerable evidence that many of these common tasks and workloads can benefit substantially(e.g., regular order-of-magnitude speedups) from this analysis. In all likelihood, you can too.

Peter Bailis (@pbailis) - UC Berkeley

Peter Bailis is a final-year Ph.D. candidate at UC Berkeley working in databases and distributed systems. As part of his dissertation work, he has studied and built high

performance distributed data management systems for large scale transaction processing, data serving, and statistical analytics in the AMPLab and BOOM projects underthe advisement of Joseph M. Hellerstein, Ali Ghodsi, and Ion Stoica. He is the recipient of the NSF Graduate Research Fellowship, the Berkeley Fellowship for GraduateStudy, and best-of-conference citations for research appearing in both SIGMOD and VLDB. He received his A.B. in Computer Science from Harvard College in 2011,where he also received the CRA Outstanding Undergraduate Researcher Award.

Literate interactive coding: Devcards

Date: 2015-09-25 13:40Room: CenteneFormat: talkTrack: web

Devcards is a ClojureScript library that is my attempt at creating a literate interactive coding style. It allows developers to interactively surface code examples into a webinterface live from the source code that they are currently editing.

Devcards works by surfacing a set cards which represent code examples. Taken together these code examples allow you to create a valuable interactive web based artifactthat both documents your code and allows you to go back and interact with your code as your project changes.

In this talk I will demonstrate why Devcards or something like it is necessary and then go on to build up an interesting program one Devcard at a time.

Bruce Hauman (@bhauman) - Dropzite LLC

Bruce has hiked the Appalachian Trail, and enjoys living in a demountable Dome of his own design.

He is the author of the blog rigsomelight.com, and the figwheel library for ClojureScript.

He is just plain addicted to programming.

"All In" With Determinism for Performance and Testing in Distributed Systems

Date: 2015-09-25 13:40Room: Midland States BankFormat: talkTrack: distributed-systems

Perform the same operations on the same starting state in the same order and you can expect the same finishing state. That's the essence of determinism; this talk will focuson its role in distributed systems.

How can we leverage deterministic operations to make distributed systems faster? When processing is replicated across two hosts to achieve high availability and safety,there is typically a trade-off between strong consistency and performance. Ensuring consistent processing requires network communication, which introduces latency. "Allin" determinism upends those tradeoffs and allows for strong consistency with drastically reduced communication overhead. This talk will lay out what assumptions aremade, how the tradeoffs have changed, and why more systems work this way.

And while everyone gets excited about performance, it turns out that a system that enforces strict determinism is easier to verify as well. The second part of this talk willfocus on the "TransactionalitySelfcheck" test system built at VoltDB to verify the strong consistency and ACID-serializable properties VoltDB promises users. One of thebenefits of strictness is that faults are easier to detect. "TransactionalitySelfcheck" relies on runtime determinism validation and a truly adversarial workload to verifycorrect processing.

John Hugg (@johnhugg) - VoltDB Inc.

John Hugg has spent his career working at several database startups including Vertica Systems and now VoltDB. As the founding engineer on VoltDB, he worked withMike Stonebraker and a team of academics at MIT, Yale and Brown who were building H-Store, VoltDB's research prototype. Then he helped build the world-classengineering team at VoltDB to continue development of the open source and commercial products.

HTTP/2 in Erlang

Date: 2015-09-25 13:40Room: Peabody LoungeFormat: talkTrack: web

HTTP/1 has had a good run, and to be honest, it's not going anywhere anytime soon. What it is doing, is going through TCP connections like nobody's business! If you'relooking to streamline communications overhead between a browser and a server or lower the network traffic of your web service calls, you might want to get on board thisHTTP/2 bandwagon.

I'm going to chat with you all about the HTTP protocol. How it does the things that it claims. What's the deal with multiplexing? What's so cool about HPACK? (Spoiler:it's the dynamic table, and the static table, and the Huffman encoding, ok there are a lot of cool parts)

We'll also talk about the Erlang server implementation I've been working on, Chatterbox. We can talk about the design choices I made and what happens when the rubberhits the road. I'll have future work outlined as well, which at some point I hope means being able to use Chatterbox as the HTTP server for WebMachine and an HTTP/2client for Erlang.

Joe DeVivo (@joedevivo) - CHEF

Joe spent about a decade writing more and more ceremonious Java before he started writing Erlang at Basho, and now CHEF. He's spoken at several Erlang conferences,but is looking forward to branching out into the broader Functional Programming world. Joe lives just outside Phoenix with his wife, daughter, and son where they playboard games, practice Tae Kwon Do, and are never ever cold.

GC Tuning Confessions Of A Performance Engineer

Date: 2015-09-25 13:40Room: Pepsi EncoreFormat: talkTrack: etc

Performance tuning is a methodical and an iterative process. It is imperative to have a performance plan coexist with a product development plan. A performance plan notonly serves to document the requirements but also feeds into designing the performance experiments and helps in providing a clear understanding of the performanceinfrastructural needs. During this session, the speaker will briefly discuss performance metrics, tuning tradeoffs and goals and will also talk about her experience withthree garbage collectors in OpenJDK's HotSpot JVM - Parallel Old, CMS and G1 and compare and contrast them.

Monica Beckwith (@mon_beck) - Code Karam LLC

Monica Beckwith is a Java Performance Consultant. She was the Java Garbage First Garbage Collector (G1 GC) Performance Lead at Oracle. Her past experiencesinclude working with Oracle/Sun and AMD optimizing the JVM for server class systems. Monica was voted a Rock Star speaker @JavaOne 2013. You can follow Monicaon twitter @mon_beck.

Ideology

Date: 2015-09-25 13:40Room: TheaterFormat: talkTrack: etc

Some claim that unit tests make type systems unnecessary: "types are just simple unit tests written for you, and simple unit tests aren't the important ones". Others claimthat type systems make unit tests unnecessary: "dynamic languages only need unit tests because they don't have type systems." What's going on here? These can't both beright.

Both of these claims stem from "unknown beliefs" held by the speakers: beliefs that they have without knowing that they have them. We'll analyze these and several otherunknown beliefs: about type systems, garbage collection, functional programming, NULL, GOTO, and some non-technical topics. Comment sections the world over willsuddenly make a little more sense.

Gary Bernhardt (@garybernhardt) - Destroy All Software LLC

Gary Bernhardt is a creator and destroyer of software compelled to understand both sides of heated software debates: Vim and Emacs; Python and Ruby; Git andMercurial. He runs Destroy All Software, which publishes advanced screencasts for serious developers covering Unix, software design, TDD, and dynamic languages.

Sweaters as a Service

Date: 2015-09-25 14:30Room: CenteneFormat: talkTrack: etc

In the 1980's, Nintendo had plans for making a knitting add-on to the NES, with an interface that resembled Mariopaint, but with patterned mittens, sweaters, and scarvesas output. Sadly, this product never saw the light of day. Devastated upon hearing this and dreaming about what could have been, a group of Airbnb engineers (who knewnothing about machine knitting) set out to hack a knitting machine from the 1980's to be computer-controlled, using a tutorial from adafruit as a starting point.

Hear about our struggles and triumphs, which ranged from learning to replace knitting machine needles and conduct basic repairs, to emulating a floppy drive and hackingtogether a custom cable cable to send our own patterns to the machine, to writing our own yarn printer API in ruby/rails and printing our first doge meme in yarn. Andwatch us as we send images and knit requests to our yarn server, and behold as it knits ugly sweaters from those images!

Amy Wibowo (@sailorhg) - BubbleSort Zines

Amy is the founder of BubbleSort Zines, zines that explain computer science concepts in engaging and accessible ways. Prior to that, she did web development at Airbnb,machine learning research on the ASIMO team at Honda Research Institute in Japan, and HCI research at the University of Tokyo. She also enjoys hardware hacking andthe intersection of art and technology-- in particular, making tools that enable people to be more creative.

Probabilistic Programs Which Make (Common) Sense

Date: 2015-09-25 14:30Room: Midland States BankFormat: talkTrack: languages

In 1854 George Boole published The Laws of Thought, and established Boolean algebra. Less well known is that half of this book was devoted to probabilistic inference.Boole dreamed of a "general method in probabilities": an algorithm which given probabilities of any system of events, could determine the consequent probability of anyother logically connected event. Like Boole, Alan Turing laid down the fundamentals of computer science, and also turned his attention to automated reasoning. Turingpresented the "imitation game" (now, the Turing Test) - a task which could only be passed by a machine which understood the world with all its ambiguities, uncertaintyand complexities; i.e., a machine with common-sense.

In this talk I present probabilistic programming as the modern realisation of Boole's general method, and a significant step towards Turing's thinking machine. I willintroduce Sigma, a language in which probabilistic models are functional programs. Sigma programs can be run forward, to for example render a 3D scene (known onlywith uncertainty) to a 2D image. More interestingly, Sigma's inference algorithms can run functions conditionally, or in reverse; so that the most probable 3D scene can beautomatically inferred from a 2D image. Through examples, I shall explain how this is possible through the combination of functional programming and methods fromstatistical inference, program analysis and constraint solving. And, if successful, how probabilistic programming will unify several ideas in logic, artificial intelligence andcognitive science.

Zenna Tavares - Massachusetts Institute of Technology

Zenna is a Ph.D candidate at MIT, interested in both Human and Artificial Intelligence. He spends his days thinking about programming languages, and how to buildcomputer programs that think as humans think (they are related!).

Gamma: A simple model for WebGL

Date: 2015-09-25 14:30Room: Peabody LoungeFormat: talkTrack: web

WebGL and its cousins are festooned with incidental complexity, resulting in low developer productivity, and brittle monolithic codebases. Typical GL frameworksintroduce a set of mutually incompatible abstractions, without fixing the core problem. Gamma provides a simple data-driven model for WebGL, much as React provides amodel for the DOM. This model makes it easy to compose and abstract WebGL using vanilla Clojure/script, allowing for simpler, more powerful, and more reusablegraphics software. Gamma also inherits Clojure's platform and library story, enabling a la carte graphics libraries and graphics application portability across web, mobile,and desktop.

Kovas Boguta (@kovasb) - Kovas Boguta

Kovas Boguta is an independent engineer and researcher associated with Kitchen Table Coders in Brooklyn. Previous to Gamma, Kovas has worked on Session (a next-generation notebook for Clojure), as a data scientist at Weebly, founder of Infoharmoni (YC-backed Twitter visualization startup), and as a research assistant to StephenWolfram on projects relating to A New Kind of Science, Mathematica, and Wolfram Alpha. Kovas enjoys cellular automata, global-scale visualization, and extremelylarge books; he just finished Francis Fukuyama's Political Order and Political Decay.

Look ma, no OS! Unikernels and their applications

Date: 2015-09-25 14:30Room: Pepsi EncoreFormat: talkTrack: architecture

Unikernels present the next iteration on application packaging, deployment, and runtime after Linux containers. With the majority of our work taking place in a virtualizedenvironment the need to support a vast array of hardware, software, and users in a single (though highly specialized) operating system is waning. In addition, the costs,complexity, and stability associated with our existing Linux based production environments leave much to be desired.

This presentation will attempt to answer the following questions:

What is a unikernel and what types are there?How is a unikernel architecture different than a traditional Linux one?What benefits does a unikernel architecture provide?How can unikernels help solve our current problems?What unikernel projects exist in the wild?What would a unikernel application architecture look like?

Matt Bajor (@mattbajor) - Rally Software

Matt Bajor is an Infrastructure Automation Engineer working for Rally Software in Boulder, CO. His background is in Systems Engineering with a good amount ofsoftware development on the side. He is very interested in problems around team structure and easing operational overhead and difficulties. Another major passion of hisis enabling development teams to own their applications through the entire lifecycle.

Building Scalable Stateful Services

Date: 2015-09-25 14:30Room: TheaterFormat: talkTrack: distributed-systems

The Stateless Service design principle has become ubiquitous in the tech industry for creating horizontally scalable services. However our applications do have state, wejust have moved all of it to caches and databases. Today as applications are becoming more data intensive and request latencies are expected to be incredibly low, we'dlike the benefits of stateful services, like data locality and sticky consistency. In this talk I will address the benefits of stateful services, how to build them so that theyscale, and discuss projects from Halo and Twitter of highly distributed and scalable services that implement these techniques successfully.

Caitie McCaffrey (@caitie) - Twitter

Caitie McCaffrey is a Backend Brat and Distributed Systems Diva working on Infrastructure at Twitter. Prior to that she spent the majority of her career building servicesand systems that power the entertainment industry at 343 Industries, Microsoft Game Studios, and HBO. Caitie has a degree in Computer Science from Cornell University,and has worked on several video games including Gears of War 2, Gears of War 3, and Halo 4. She maintains a blog at CaitieM.com and frequently discusses technologyand entertainment on Twitter @Caitie

The art of service discovery at scale

Date: 2015-09-25 15:40Room: CenteneFormat: talkTrack: distributed-systems

Whether it is a simple DNS lookup or a complex dedicated solution, service discovery is the backbone of any microservices architecture and an immature solution can

soon turn into an achilles' heel.

Nitesh Kant in this talk will introduce the concept of service discovery and various use cases it solves in a complex service based architecture. He will then be introducingNetflix's Eureka (https://github.com/Netflix/eureka); a highly-available, multi-datacenter aware service discovery solution built from scratch, it's architecture and how it isunique in this space, by favoring Availability over Consistency in the wake of network partitions.

Nitesh Kant (@NiteshKant) - Netflix

Nitesh Kant is an engineer in Netflix's Cloud Platform team, working on their Inter Process Communication stack. He is the author of RxNetty(https://github.com/ReactiveX/RxNetty) which forms the core of Netflix's IPC stack. He is also a contributor to other Open source projects like Eureka(https://github.com/Netflix/eureka) and Karyon (https://github.com/Netflix/karyon)

Beating Threads - live coding with real time

Date: 2015-09-25 15:40Room: Midland States BankFormat: talkTrack: languages

Live Coding systems encourage us to think extremely differently about programming languages. In addition to considering standard requirements such as reliability,efficiency and correctness we are also forced to deal with issues such as liveness, coordination and synchronisation all whilst working in real time. Live Coders not onlyrun and modify our code live - we often perform with it live on stage in front of large crowds of people who really don't want the code to miss a beat.

In this code and demo-heavy talk we will take a deep technical dive into the internal ideas and innovations of Sonic Pi - a system designed specifically for live coding. Wewill explore Sonic Pi's novel temporal semantics which allow multiple concurrent threads to execute in synchronisation whilst still allowing live hot-swapping of code. Forexample, we will examine cue and sync, techniques which allow users to coordinate, manipulate and synchronise threads whilst they're still running. We will discoverwhat it means for lambdas to close over temporal as well as lexical scope and finally we'll understand the importance and challenges in achieving repeatable, deterministicexecution semantics.

Ultimately, we will uncover an exciting area of programming language research in an approachable and instructive manner all whilst making some sick beats and drops.

Sam Aaron (@samaaron) - The University of Cambridge

Sam is a live coder who strongly believes in the importance of emphasising, exploring and celebrating creativity within all aspects of programming. He is the leaddeveloper of Overtone and the creator of Sonic Pi, a music live coding environment used to teach programming within schools. By day Sam is a Postdoc ResearchAssociate at the University of Cambridge Computer Laboratory and by night he codes music for people to dance to.

rustc in userland

Date: 2015-09-25 15:40Room: Peabody LoungeFormat: talkTrack: languages

A neat feature of rust's compiler architecture is that all of it's internals are present in a rustc install- meaning that unlike nearly any other AOT compiled language, you getall the machinery to parse source code, transform, and emit object files from userland code. This offers you a lot of scope for implementing two types of tools thattraditionally have had little language/standard library support: Static analysis tools, and compilers.

This talk will dive into the machinery that rust offers you to do this, as a side effect of the compiler's modularity. Covered will be writing a simple static analyser (distinctfrom the macro, and compiler plugin infrastructure); which is unfortunately rust specific and comparitively uninteresting. Following up, we'll demonstrate how to writeRust programs that excercise the Rust codegen machinery at runtime, to implement a simple LISP that emits native objects using rust's packaging machinery. Finally we'lldive into some more platform specific hacks that can be used to fake out a JIT compiler using these techniques.

Richo Healey (@rich0H) - Stripe

Richo likes his ducks flat and his instruction sets reduced. Currently a Security Engineer at Stripe, richo's disdain for computers has been fueled by his career acrosssecurity, distributed systems, operations and development. At night, he dons a scarf (capes are so last year) and writes open source code to distract him from securityresearch.

Cache à la carte: a framework for in-memory caching

Date: 2015-09-25 15:40Room: Pepsi EncoreFormat: talkTrack: distributed-systems

In-memory caching is not a single problem but many. At Twitter, one cache client must store myriad tiny objects, another requires fast updates of large values, and a thirdwants to replace in-process cache in Java with an equally fast cache outside the JVM to avoid garbage collection. Optimizing for one of these use cases takes carefullychoosing data structures, memory layout, eviction strategy, and transport medium. Existing solutions often bake details of these low-level components into their overalldesigns, and it can be messy and costly, or sometimes impossible, to introduce alternative parts to an established codebase.

After years maintaining forks of the popular Memcached and Redis projects, both relatively monolithic designs, Twitter is starting with a clean slate, a new modular cacheframework built out of small composable pieces. The use of common interfaces regulates and limits the surface area of individual components, supporting radicallydifferent implementations behind the interface. Production critical features such as managed resources, logging, and statistical measurements are core priorities rather thana bolted-on afterthought.

We generate binaries that offer highly predictable tail latencies even at near 100% CPU utilization, a fixed memory footprint (no more out-of-memory shutdown in acontainer environment), and readable logs and metrics that are cheap to collect and readily available when you need them for debugging. Moreover, it is now easy toimplement new cache backends with small amount of effort: we added support for memcached and redis protocols, and implemented a new storage engine backed by

cuckoo hashing that achieves a 90% reduction in metadata overhead, each in about 1000 LOC on top of the core library. Future users with substantially different needs caneasily swap out parts while avoiding duplicating the work already done.

Through this talk, I also want to share the lessons we learned from years of operating large-scale cache clusters in production. Building operations-friendly systems israrely about a single clever trick; more important is for engineers and architects to acquire and practice insight, discipline and common sense.

We plan to open source the code and documentation about this project in time for the talk.

Yao Yue (@thinkingfish) - Twitter

Yao Yue is a member of Twitter Platform. She is the tech lead and manager of the Cache Team, and has spent the past few years maintaining, designing and implementingvarious cache-related projects. She maintains several open source projects, including Twemcache and Twemproxy.

Yao has a particular interest in building and simplifying systems deployed at-scale. Over the years she has spent much time studying and playing with computer networks,various distributed systems, databases, and parallel programming. Yao has a BS in Math and Physics and a MS in Computer Science. Before joining Twitter, she internedat Facebook, NVIDIA and IBM Research.

In her spare time, Yao has been introducing programming to middle/high school girls via drawing and games. She is also a baker.

Apache Kafka and the Next 700 Stream Processing Systems

Date: 2015-09-25 15:40Room: TheaterFormat: talkTrack: distributed-systems

Most software systems continuously transform streams of inputs into streams of outputs. Yet the idea of directly modeling stream processing in infrastructure systems isjust coming into it's own after a few decades on the periphery.

This talk will cover the basic challenges of reliable, distributed, stateful stream processing. It will cover how Apache Kafka was designed to support capturing andprocessing distributed data streams by building up the basic primitives needed for a stream processing system.

Finally it will explore how these kind of infrastructure maps to practical problems based on our experience building and scaling Kafka to handle streams that capturedhundreds of billions of records per day.

Jay Kreps (@jaykreps) - Confluent

Jay Kreps is the CEO of Confluent, Inc. He was formerly the lead architect for data infrastructure at LinkedIn. He is among the original authors of several open sourceprojects including Project Voldemort, a key-value store, Apache Kafka, a distributed messaging system, and Apache Samza a stream processing system.

From Protesting to Programming: Becoming a Tech Activist

Date: 2015-09-25 16:30Room: TheaterFormat: keynoteTrack: keynote

Civil unrest is growing exponentially around the world as more protests, organized resistance, and uprisings occur in response to increased brutality against oppressedcommunities. Now more than ever, millions of people across demographics and in communities all over the world are rising together to resist exploitation, racism, andstate terrorism. How do technology and the technologist play a role in activism? How is technology both helping and hindering the effectiveness of activism? And moreimportantly, how do we hold technologists accountable for creating socially aware, community-conscious, and politically committed techies, and not just settle fordiversifying the tech sector in appearance?

Technology activist and social entrepreneur Abby Bobé will address these vital questions and tell the story of her personal journey from being the first person in herfamily to go beyond middle school, overcoming life's obstacles as a poor Afro-Latina, to becoming a leading advocate at the intersection of technology and social justice,educating thousands of men, women, and youth along the way. The North Philly native will share her experience and key learnings about how youth in Ferguson,Missouri, went from protesting police brutality and racism in the aftermath of the killing of Michael Brown in August 2014 to learning technology skills and bringing therevolution to the cloud. We will also learn how empathy and human-centered design plays a major role in tech activism.

Abby Bobé (@abbybobe) - ThoughtWorks

Idalin "Abby" Bobé is an IT consultant at ThoughtWorks and a tech activist. Her passion is in bridging the digital divide among hard-to-reach populations and creatingmore technical community-driven leaders. Originally from the North Side of Philadelphia, Abby has impacted thousands of men, women and children globally with herwork in tech literacy and empowerment. Her work includes spearheading tech initiatives within organizations like Hands Up United, India Rise, Black Girls CODE,Qeyno Labs Hackathons, and #YesWeCode. Still under 35, Abby is a rising social entrepreneur, whose work has positioned her at the forefront as an innovative leader intechnology, activism and community development.

Saturday, Sept 26thDreaming in Lambdas: why should AI's have all the fun?

Date: 2015-09-26 09:10Room: TheaterFormat: keynoteTrack: keynote

Deep Learning shocked AI back to life with astonishing breakthroughs in recognition and classification. But while we celebrate the progress of our future overlords, arewe missing a crucial point? The algorithms and high-level approach for helping machines learn more like humans actually WORK. But what do we do? We find this

largely hidden superpower for human learning, then apply it to help computers, but not humans, learn better and faster.

Deep Learning draws in part on dusty, decades-old research on human perception And much of that research - on humans - was as dramatic as today's AI breakthroughs.Lurking in that work is a treasure of studies on how humans can learn artificial, extremely complex rule-based grammar systems at near-unbelievable speeds and, moreimportantly, with far less sensitivity to individual cognitive differences. With trips along the way from the Tetris Effect to Alan Kay's take on Gallwey's "Inner Game ofTennis", we'll look at the implications of AI's Deep Learning for designing and learning programming languages.

Kathy Sierra

Kathy Sierra worked as a game programmer, interaction designer, and learning specialist (Sun Microsystems, UCLA Extension) before creating the best-selling Head Firstseries for O'Reilly. She was the original creator of one of the largest software developer communities, javaranch.com.

The Programming Language Called Classical Chinese

Date: 2015-09-26 10:10Room: CenteneFormat: talkTrack: etc

In this talk I present some of the ideas of context-free grammars and type systems, using Classical Chinese (the written language of common East Asian tradition) for theexamples. Why Classical Chinese? Because you can fully describe the syntax of Classical Chinese using simple cases of these bedrock programming-language principles.What an astonishing and beautiful fact!

As I introduce the principles I will illustrate them with actual examples, so that the discussion stays concrete. But you will need no prior exposure to Chinese; I willsupplement Chinese script with tokens that monolingual English speakers can read.

This talk comes out of a long gestation — years of working to make Classical Chinese accessible to learners in their early stages, and then coming to grips with theoreticalcomputer science for myself. My aims are for the listener to observe how to apply basic ideas of context-free grammar and type systems to a highly unusual subject — andin the process to learn the outline of the elegant logical system at the core of Classical Chinese.

David Branner

David Branner is a student of Chinese language in its many forms and time-periods. After an academic career in the subject, he retired very early from his university andeventually found a more satisfying way to prosecute this quest by working as a coder. While following this path he spent the better part of two years at the Recurse Centerin New York.

Hopelessness and Confidence in Distributed Systems Design

Date: 2015-09-26 10:10Room: Midland States BankFormat: talkTrack: distributed-systems

When designing real-world distributed applications, we face many decision points. Understanding the tradeoffs that we face at these decision points lets us make smarterchoices faster. This talk will discuss a series of real-world distributed applications built by the speaker and some of the key tradeoffs that were made in these systems. Thisis a pragmatic talk for an audience who is eager to go beyond hope and fear into the lightness of hopelessness and confidence.

Camille Fournier (@skamille) - Rent the Runway

Camille Fournier is the CTO of Rent the Runway, where she and her team of 65 (and growing!) engineers are helping to build the world's first rental platform for luxurygoods. Prior to Rent the Runway she was a Vice President at Goldman Sachs, specializing in infrastructure systems. In her limited spare time she contributes to theApache ZooKeeper project as a committer and PMC member, and helps to oversee the Dropwizard web framework.

Specter: overcome your fear of nested Clojure data

Date: 2015-09-26 10:10Room: Peabody LoungeFormat: talkTrack: languages

Clojure revolves around immutable values and manipulation of those values. However, it does not provide good mechanisms for manipulating combinations of thosevalues: like a map of sequences of maps of maps. Code that aims to manipulate these nested data structures complects navigation code with the desired query ortransformation. Code like this is painful to write and ugly to read.

Specter is a library that makes querying and transformation of nested data structures simple, easy, and efficient. At its core it abstracts away the concept of data structurenavigation and makes these navigations highly composable. Specter can manipulate any of Clojure's maps, sequences, records, and sets, and by hooking into Specter'sprotocols you can use it to manipulate any data structure. On top of all this, Specter is highly performant: for example, Specter's equivalent to update-in runs 5x faster.Once you've used Specter, it's hard to imagine programming Clojure without it.

Nathan Marz (@nathanmarz) - Red Planet Labs, Inc.

Nathan is the creator of the open source projects Apache Storm and Cascalog. He is the author of the book "Big Data: principles and best practices of scalable realtimedata systems". He was the lead engineer of BackType until BackType was acquired by Twitter. At Twitter, he created the streaming compute team, a core infrastructureteam within the company. He left Twitter in 2013 to work on a new startup. When not coding, you can often find him 3500 feet overhead, flying a small plane andenjoying the view.

Side Effects are a Public API

Date: 2015-09-26 10:10Room: Pepsi EncoreFormat: talkTrack: languages

Haskellers have been isolating their side-effects from their pure code for decades, but most people write code in languages that allow ad hoc side-effects anywhere. In a lotof cases, these side-effects are practically a part of the public API -- they put restrictions the way the code can be used, often obscurely, and have effects that areobservable to the caller. It helps a lot to acknowledge this and explicitly treat them as a part of your public API. Here are the basic ideas that I'll cover:

represent your side-effects as "intents to perform an action" -- transparent objects that expose the details of the side-effect, without actually performing itcombine effects with pure code to describe the execution order and data dependencies (yes, like a monad)write unit tests for your code without mocking, by specifying the expected content, results, and order of side-effects performed by a function

I'll show a library implemented for Python, called Effect, that provides tools for doing this.

A lot of these ideas are similar to the Extensible Effects system described for Haskell, and I'll describe some ideas and techniques that even most Haskellers could useto make their code more easily testable.

Christopher Armstrong (@radix) - Rackspace

Christopher Armstrong is a long-time writer of Python code, who recently immersed himself in the world of purely functional programming. He is a long-time contributorto the Twisted networking framework, and more recently has been working on the Effect library. He is also a budding Haskell enthusiast.

Streams: The data structure we need

Date: 2015-09-26 10:10Room: TheaterFormat: talkTrack: web

There's a data structure that essentially makes you a wizard and that data structure is streams. In this talk, you'll learn more about the best data structure you didn't knowenough about. There will be history, there will be a real-world demo, and there will be examples of how to leverage this power in JavaScript. Expect walk away havinglearned about IO streams, ES6 generators, current developments, and being really excited about this awesome data structure.

Pam Selle (@pamasaur)

Pam Selle is a software engineer, published author, and public speaker. A fan of learning new and old languages, she largely works with JavaScript and organizesPhiladelphia's largest JavaScript user group as well as the regional JavaScript conference, LibertyJS.

No, Really... Robots and JavaScript?!

Date: 2015-09-26 11:00Room: CenteneFormat: talkTrack: etc

NodeBots have been around for several years now, but with every presentation, there is always someone who asks, "But... JavaScript?! Why on earth would you makerobots with JavaScript?"

It's a fair question, and one worthy of more than a hand-wavy answer about how it's cool... or something.

In this talk, let's discuss why, of all the languages on the planet, JavaScript is the perfect starting point for a future of robotics.

As a roboticist-turned-web-developer, I will provide some deep insights not only into the world of robotics, but also into JavaScript and its server-side cousin, Node.js.We'll talk about what JavaScript-enabled robots can already do, what they can't do yet, and what they might be able to do with a bit of elbow grease.

And, if the demo deities are with us, we may even have a robot assistant on hand.

Raquel Vélez (@rockbot) - npm, Inc.

Raquel Vélez is a Senior Software Developer at npm, Inc. in Oakland, CA. She has previously worked at institutions such as Caltech, NASA JPL, the MIT LincolnLaboratory, and various universities in Europe. In her off time, you can find her baking, teaching NodeBots not to fall off of tables, and speaking. Also, hanging out withher hilarious husband and two cats dressed in dog suits.

Pixie - A Lightweight Lisp with 'Magical' Powers

Date: 2015-09-26 11:00Room: Midland States BankFormat: talkTrack: languages

This will be an overview of the Pixie programming language. We will start with a few words about the niche that Pixie is trying to fill and then move on to the mainfeatures of the language, including: excellent C interop, immutable data structures, lightning-fast startup times, "good-enough" execution performance, and async-by-default io. We will also touch briefly on the technology (RPython) that has enabled Pixie to grow from nothing to a usable language in less than a year, and yet stillsupport the major *nix OSes as well as run on x86 and ARM.

Timothy Baldridge (@timbaldridge) - Cognitect

Timothy is a developer with Cognitect Inc. He hails from the mountain regions of Denver Colorado (USA). Timothy is a polyglot programmer with experience in Clojure,

C#, Python, and Erlang. He's the author of the Pixie Language and Clojure's core.async 'go' macro.

CRDTs Illustrated

Date: 2015-09-26 11:00Room: Peabody LoungeFormat: talkTrack: distributed-systems

CRDTs (Conflict-Free Replicated Data Types) are a great way to implement applications that gracefully recover from partitions - such as clusters or (mobile) applicationsthat can work offline.

This talk will:

Introduce the concept of CRDTs and their use casesDescribe the 2 main ways to implement a CRDT (convergent and commutative), with visual examples to illustrate their behaviorShow 2 examples of CRDTs used in practice (RIAK 2 Data Types (distributed storage) and swarm.js (offline-friendly web apps))

Arnout Engelen (@raboofje) - Xebia

With over a decade of experience in professional software development, Arnout is constantly on the lookout for tools to smoothen and simplify that process. He currentlyconsults for Xebia, injecting the startup mentality into larger corporations in the Netherlands.

Non-Imperative Network Programming

Date: 2015-09-26 11:00Room: Pepsi EncoreFormat: talkTrack: etc

Network programming is often taught and practiced in C, but it doesn't have to be. We can build better network stacks -- ones more expressive, intuitive, and robust -- inother languages! There are many non-C network stacks in the world, and we can learn a lot from the diversity of solutions for common problems.

How can we handle side effects like cache entry aging and connection timeouts when using immutable data structures? How can strong types or GADTs help us expressvalidation logic in packet inputs? Many languages have libraries for property-based tests -- let's use them to go beyond the admittedly-useful property "doesn't crash oninvalid input".

Mindy Preston (@mindypreston) - University of Cambridge

Mindy Preston is a research assistant at OCaml Labs in the University of Cambridge, where she works on MirageOS. She enjoys packets, memory safety, petting cats,small and strange ARM boards, riding bicycles, and deleting great big gobs of code.

Transactions: myths, surprises and opportunities

Date: 2015-09-26 11:00Room: TheaterFormat: talkTrack: data

Back in the 1970s, the earliest databases had transactions. Then NoSQL abolished them. And now, perhaps, they are making a comeback... but reinvented.

The purpose of transactions is to make application code simpler, by reducing the amount of failure handling you need to do yourself. However, they have also gained areputation for being slow and unscalable. With the traditional implementation of serializability (2-phase locking), that reputation was somewhat deserved.

In the last few years, there has been a resurgence of interest in transaction algorithms that perform well and scale well. This talk answers some of the biggest questionsabout the bright new landscape of transactions:

What does ACID actually mean? What race conditions can you get with weak isolation (such as "read committed" and "repeatable read"), and how does this affectyour application?What are the strongest guarantees we can achieve, while maintaining high availability and high performance at scale?How do the new generation of algorithms for distributed, highly-available transactions work?Linearizability, session guarantees, "consistency" and the much-misunderstood CAP theorem -- what's really going on here?When you move beyond a single database, e.g. doing stream processing, what are your options for maintaining transactional guarantees?

Martin Kleppmann (@martinkl)

Martin Kleppmann is a software engineer and entrepreneur, and author of the O'Reilly book Designing Data-Intensive Applications (http://dataintensive.net), whichanalyses the data infrastructure and architecture used by internet companies. He previously co-founded a startup, Rapportive, which was acquired by LinkedIn in 2012. Heis a committer on Apache Samza, and his technical blog is at http://martin.kleppmann.com.

PTero: Architecture and Development of a Scalable Execution System for Complex Workflows

Date: 2015-09-26 12:50Room: CenteneFormat: talkTrack: etc

Analyzing genomic sequence data requires non-trivial computational workflows that can be highly parallel. Managing these workflows at scale is a significant challenge

both in terms of performance and fault tolerance. A survey of available workflow management systems did not yield a candidate that met our needs. Therefore, we aredeveloping a workflow system called PTero.

Workflow systems usually represent workflows as a set of simple tasks arranged in a directed acyclic graph. Because real world applications often require choices to bemade at run-time, those tasks become complicated finite state machines. PTero uses petri nets, which are capable of representing both DAGs and FSMs in one datastructure. The system is able to handle very large workflows due to the amortized constant time algorithm used to determine whether the next step in the workflow can beexecuted.

PTero consists of a set of restful services that work together to execute workflows but can also be used individually. Following the 12-factor recommendations allows usto scale horizontally and be resilient in the face of single node failures. The service oriented architecture also provides a clear extension path for adding executionschedulers such as SGE, AWS or OpenStack.

Since the first version of PTero was deployed at the McDonnell Genome Institute at Washington University in the summer of 2013, it is has orchestrated more than600,000 workflows and with over a combined 8 million tasks. Since then development has focused on making the system more accessible to the community.

Michael Kiwala - McDonnell Genome Institute at Washington University

Michael Kiwala works on PTero at the McDonnell Genome Institute at Washington University. Michael has served at MGI as a software engineer, automating genomicdata analysis and sharing the results with the scientific community since 2005.

David Morton - McDonnell Genome Institute at Washington University

David Morton is the Project Lead for PTero at the McDonnell Genome Institute at Washington University. David received his PhD from Washington University in SaintLouis in 2012 where he worked to automate the acquisition and analysis of data in a neurophysics lab. Since then he has been a member of the development team workingto create the infrastructure that enables large scale genome sequencing at MGI.

Make the Back-End Team Jealous: Elm in Production

Date: 2015-09-26 12:50Room: Midland States BankFormat: talkTrack: languages

How often do you find a back-end team jealous of the language the front-end team gets to use? Having modernized many legacy front-ends over the years, I canunequivocally say that introducing the Elm programming language to a rich web app (previously built on a mix of React.js and legacy jQuery) has yielded the mostreliable, clean, and performant result I've ever seen. Elm's benefits to this mission-critical code have felt like the programming equivalent of the "After" photo in aninfomercial.

In this talk attendees will learn how to cleanly introduce Elm into an existing JS front-end from start to finish. Highlights include Elm's Time-Traveling Debugger, itsuncanny ability to catch nearly all runtime exceptions at build time (no more "undefined is not a function"), and a package manager that guarantees and automaticallyenforces semantic versioning for every package.

Attendees are assumed to be comfortable with JavaScript and CSS, but no other knowledge is needed. Come see how nice your front-end programming experience canbecome!

Richard Feldman (@rtfeldman) - NoRedInk

Richard is a functional programmer who specializes in pushing the limits of browser-based UIs. He's built a framework that performantly renders hundreds of thousands ofshapes in HTML5 Canvas, a JavaScript immutables library that seamlessly interoperates with normal JS collections, and a Web App for long-form writing that functionslike a desktop app in the absence of an Internet connection.

Kolmogorov music

Date: 2015-09-26 12:50Room: Peabody LoungeFormat: talkTrack: etc

Kolmogorov complexity analysis suggests that we can measure how well we understand a piece of music by the concision of a program that produces it. Furthermore, theinherent complexity of grooves and fugues can be compared via the lengths of their programmatic representations, and their relationship can be described as a programtransformation. Algorithmic composition has curious implications for the creation, copyright and performance of pieces, both finite and infinite. Expect (finite)demonstrations.

Chris Ford (@ctford) - ThoughtWorks

Chris is a certified BABE (Bachelor of Arts, Bachelor of Engineering), and consequentially an idiophile and technophobe. He began to make music with code partly tocompensate for his poor technique, and partly because air piano is unsatisfying. When he works, he works for ThoughtWorks, though that isn't all the time.

Aggregator: MapReduce in the type system

Date: 2015-09-26 12:50Room: Pepsi EncoreFormat: talkTrack: data

Users of Hadoop will recognize, behind the buzzwords, yet another implementation of the oldest pattern in the data aggregation book. In this talk, we'll walk through thebasics of the MapReduce pattern, from GROUP BY in sql to split-apply-combine in Python's Pandas. We'll tease apart the differences between the infrastructure-levelimplementation of the MapReduce engine (how are elements grouped and stored) and the application-level definition of the job (how are grouped elements combined, or"reduced"). We'll then introduce the Aggregator trait in Twitter's Algebird library, which neatly captures the application logic of a MapReduce operation in a Scala type.

We'll have a look at some of the stock Aggregator implementations that ship with Algebird, from basic to esoteric.

When you look at the pattern apart from the implementation, you'll start to see it all over your code, from rate-limiting to comment ranking. We'll take a look at how weput these concepts into practice at Stripe in an online fraud detection system. Using Aggregator in combination with Twitter's Summingbird, we're able to run the sameapplication logic on Storm and Hadoop, giving us access to sophisticated fraud signals in real time. Of course, nothing is without tradeoffs, and we'll also examine some ofthe limitations that Aggregators impose, and compare this application to other systems with similar goals.

Attendees should emerge with new recognition of a common thread through many of their projects, and an itch to try out a new library or two. You don't need to knowanything about Scala, MapReduce, or type theory to follow this talk, but hopefully I can teach you a bit and convince you to learn some more.

Dan Frank (@danielhfrank) - Stripe

Dan grew up in Brooklyn, with the mathematical distinction of occupying the zip code corresponding to the first five digits of the Fibonacci sequence - if you start at 1. Heearned a degree in Math from Yale, and has since been working as a developer at small startups that process large quantities of data, much of it generated in 140 characterincrements. He is currently a member of the realtime data team at Stripe. When not in front of a monitor, he can often be found endangering himself on mountains.

Distributed, Eventually Consistent Computations

Date: 2015-09-26 12:50Room: TheaterFormat: talkTrack: distributed-systems

Consistency is hard and coordination is expensive. As we move into the world of connected 'Internet of Things' style applications, or large-scale mobile applications,devices have less power, periods of limited connectivity, and operate over unreliable asynchronous networks. This poses a problem with shared state: how do we handleconcurrent operations over shared state, while clients are offline, and ensure that values converge to a desirable result without making the system unavailable?

We look at a new programming model, called Lasp. This programming model combines distributed convergent data structures with a dataflow execution model designedfor distribution over large-scale applications. This model supports arbitrary placement of processing node: this enables the user to author applications that can bedistributed across data centers and pushed to the edge. In this talk, we will focus on the design of the language and show a series of sample applications.

Christopher Meiklejohn (@cmeik) - Machine Zone, Inc.

Christopher Meiklejohn is a Senior Software Engineer with Machine Zone, Inc. working on distributed systems. Previously, Christopher worked at Basho Technologies,Inc. on the distributed key-value store, Riak. In his spare time, Christopher develops a programming language for distributed computation, called Lasp. Christopher isstarting his Ph.D. studies at the Université catholique de Louvain in Belgium in 2016.

Performance Engineering At MasterCard

Date: 2015-09-26 13:40Room: CenteneFormat: talkTrack: etc

Real-time processing of transactions at MasterCard is not a nice to have, it is a must. And with credit card fraud running rampant, we have to be smarter and faster than thefraudster to protect our cardholders. In real-time, MasterCard needs to identify fraud real-time and decline a transaction before any exposure takes place. Oh, and by theway, this work is measured in milliseconds and occurs tens of thousands of times per second. To accomplish this is no small feat. From application, network, disk andmemory i/o, java garbage collections and a myriad other issues, we have found solutions to handle this volume quickly with a high rate of success. I will discuss lessonslearned and techniques regarding architecting systems for performance, how to create and implement a performance testing strategy. This strategy includes isolating tiersand testing to find their breaking point, monitoring systems to find issues, creating a capacity and demand model for the multiple tiers to find out their effect on each typeof hardware and how it might cause issues with other tiers, understand Java garbage collection strategies, and more.

Ted Boehm (@tedcboehm) - MasterCard Worldwide

I have been a Senior Technical Consultant at MasterCard Worldwide for nine years. I have worked on application architecture for a majority of my career with a recentfocus on high-volume, low latency performance engineering.

How to run Neural Nets on GPUs

Date: 2015-09-26 13:40Room: Midland States BankFormat: talkTrack: architecture

This talk is just what the title says. I will demonstrate how to run a neural net on a GPU because neural nets are solving some interesting problems and GPUs are a goodtool to use.

Neural networks have regained popularity in the last decade plus because there are real world applications we are finally able to apply them to (e.g. Siri, self-driving​cars, facial recognition). This is due to significant improvements in computational power and the amount of data that is available for building the models. However, neuralnets still have a barrier to entry as a useful tool in companies because they can be computationally expensive to obtain value and implement.

GPUs are popular processors in gaming and research due to their computational speed. Deep Neural Net's parallel structures (millions of identical nodes that perform thesame operation on different data), are ideal for GPU's. Depending on the neural net, you can use a single server with GPUs vs. a CPU cluster and improve communicationlatency as well as reduces size and power consumption. Running an optimization method (training algorithm) like Stochastic Gradient Descent on a CPU vs. a GPU can beup to 40 times faster.

This talk will briefly explain what neural nets are and why they're important, as well as give context about GPUs. Then I will walk through the code and actually launch aneural net on a GPU. I will cover key pitfalls you may hit and techniques to diagnose and troubleshoot. You will walk away understanding how to approach using GPUson your own and have some resources to dive into for further understanding.

Melanie Warrick (@nyghtowl) - Skymind

Deep Learning Engineer at Skymind. Previous experience included data science and engineering at Change.org and a comprehensive consulting career. I have a passionfor working on machine learning problems at scale and AI.

How the web is democratizing science (join in!)

Date: 2015-09-26 13:40Room: Peabody LoungeFormat: talkTrack: web

I've spent the past 6 years using the web to help researchers do science. The thing about the web is, it's open to everyone! While making tools to help scientists, we'vecoincidentally given anyone the power to access and analyze the same datasets. Research is no longer confined to the ivory tower of peer reviewed scientists. Anyone withan idea can test it out. We're beginning an age of democratized science.

This is where developers and computer scientists can have a huge mark on scientific discovery. Science is now facing problems that are particularly interesting to softwaredevelopers. With better sensors, sequencers and methods, research groups are producing more data than they've been trained to handle. Problems we are used to, like datamanagement, analysis and visualization, can be huge blockers to researchers.

This leaves us with the opportunity and skill to solve some of the most meaningful problems out there today. I'll demo some web tools I've worked on at the OntarioInstitute for Cancer Research to show how some simple data visalizations in the browser helped scientists do their job. I'll also introduce a platform we built at the MozillaScience Lab to help bring open source practices and collaboration to research.

We're in a new era where science is using the web to be more collaborative. I write code to help solve problems that have a huge affect on our world. You can to.

Abigail Cabunoc Mayes (@abbycabs) - Mozilla Foundation

Hi, I'm Abby Mayes (née Cabunoc), lead developer for the Mozilla Science Lab. I want to use the web to help more science forward. I build tools for and with the researchcommunity while engaging and helping scientists leverage the open web. Prior to joining Mozilla, I worked as a bioinformatics software developer at the Ontario Institutefor Cancer Research where I lead development on tools helping researchers study C. elegans and related nematodes.

With my background bridging the gap between science and the web, I've presented in both academic and instructional capacities to a diverse set of audiences ranging fromscientific meetings to tech meetups. I love helping these different worlds understand each other and work together. I've spoken across the continent at institutions like theUniversity of Toronto, UCLA, University of Wisconsin-Madison, Caltech and more.

Using Race Conditions in Correct Concurrent Software

Date: 2015-09-26 13:40Room: Pepsi EncoreFormat: talkTrack: concurrency

If you've ever worked on concurrent or parallel systems, race conditions have invariably plagued your existence. They are difficult to identify, debug, and nearlyimpossible to test repeatably. While race conditions intuitively seem bad, it turns out there are cases in which we can use them to our advantage! In this talk, we'll discussa number of ways that race conditions -- and correctly detecting them -- are used in improving throughput and reducing latency in high-performance systems.

We begin this exploration with a brief discussion of the various types of locks, non-blocking algorithms, and the benefits thereof. We'll look at a naive test-and-setspinlock and show how introducing a race condition on reads significantly improves lock acquisition throughput. From here, we'll investigate non-blocking algorithms andhow they incorporate detection of race events to ensure correct, deterministic, and bounded behavior by analyzing a durable, lock-free memory allocator written in C usingthe Concurrency Kit library.

Devon O'Dell (@dhobsd) - Fastly

Devon H. O'Dell is a recovering competitive Guitar Hero and Rock Band addict, but still occasionally enjoys rhythm games and jamming on his ESP Ltd H7-2015. Today,he is a software engineer at Fastly, where he contributes primarily to the performance and debugging of low-level systems. Prior to Fastly, Devon was Lead SoftwareArchitect at Message Systems, and contributed heavily to the Momentum high-performance messaging platform. His experience over the last 15 years ranges from webapplications to embedded systems firmware (and most areas in-between). His primary technical interests are developing and debugging high-performance, concurrentnetwork systems software and related tools.

A History of Programming Languages for 2 Voices

Date: 2015-09-26 13:40Room: TheaterFormat: talkTrack: etc

Taking inspiration from Guy Steele's classic talk "Growing a Language", and Buckminster Fuller and John McHale's superscale diagrams, we present a whirlwind tour ofthe history programming languages set to music. We propose a series of historical correspondences between significant (and not so significant) expressions of recordedmusic and programming language theory. Our milieu is a detailed timeline of programming language developments, including the creation and development of everysignificant programming language paradigm. On top of that we overlay an idiosyncratic selection of albums and performances meant to highlight the achievements of eachlanguage. By contrasting the histories of programming languages and music, we hope to deepen our appreciation of two of the most fertile human activities of the last 200years.

David Nolen (@swannodette) - Cognitect

David Nolen is a software engineer at Cognitect. He works on ClojureScript and Datomic. He likes music.

Michael Bernstein (@mrb_bk) - Code Climate

Michael R. Bernstein is staring at a pile of papers and has highlighter all over his face. Don't be scared though, he would love to chat.

Cursors Illustrated: Collaborative sketching for better understanding of functional programming and the web

Date: 2015-09-26 14:30Room: CenteneFormat: talkTrack: web

Sketches have a unique power to convey complicated ideas quickly between people. This talk will explore the functional programming concept of cursors, through the lensof sketchnoting. Cursors, immutability and React.js will provide the backdrop for an illustration of how collaborative drawing can illuminate and bring sharedunderstanding to deep technical topics.

The mainstreaming of functional programming is happening with the adoption of React.js, a framework that encourages the use of immutable data. Cursors, a conceptfrom the Clojure framework OM, are a way to work with immutable data in javascript. React.js encourages a one way data flow pattern for building web applicationscalled Flux. Cursors provide a mechanism for this.

The audience will be given an intro to sketching with basic shapes before the deep dive commences with a review of the concept of immutable data and why React.jsencourages immutable data for building web applications. Cursors will be introduced as a way to work with immutable data in javascript followed by an example of howto use them in React.js.

Takeaways will be an understanding of why immutability and cursors are important for building web apps with React.js and an understanding of how sketching can makeadvanced ideas and concepts more approachable for team discussion.

Ryan Dy (@rdy) - Pivotal Labs

Ryan Dy is javascript developer living in San Francisco. A TDD enthusiast, Ryan enjoys building single page apps and exploring the bounds of functional programming.When he is not pairing on javascript at Cloud Foundry, he works on his side project, Reddizen, a single page reddit client built with React.js and Express.js.

Marlena Compton (@marlenac) - IBM BlueMix Garage

Marlena Compton, creator of Relax Ipsum, is a javascript developer, writer and artist in San Francisco. She began creating sketchnotes at conferences as a way to listenmore carefully for each speaker's message but found that sketching quickly became a way to get a better understanding of dense technical topics. She blogs about softwareand writing at marlenacompton.com

When the OS gets in the way.

Date: 2015-09-26 14:30Room: Midland States BankFormat: talkTrack: tools

Modern operating systems are complex beasts, responsible for sharing hardware resources between many competing programs. For low-latency systems, sometimes it'snecessary to subvert the OS to grab back the resources your program needs. In this talk, we will explore what is actually going on when you run a program, how muchtime it actually gets on CPU, and strategies to help make your code run as fast as possible. By the end of this talk, you will know how to tune your software and the linuxkernel to get the most from your hardware, and more importantly, how to validate that your changes have worked.

Mark Price - LMAX Exchange

Mark is a Senior Developer at LMAX Exchange. He has been working on low-latency systems for over 10 years. Mark has helped the LMAX technology stack maturefrom start-up level to its current form. Along the way, he has specifically focussed on the limits of Java performance and the interactions between the JVM and its hostoperating system.

Feet in Both Worlds: From Objective-C to Swift

Date: 2015-09-26 14:30Room: Peabody LoungeFormat: talkTrack: languages

In 2014, Apple began the long process of replacing Objective-C, the platform's primary language for fifteen years. Swift's feature set takes cues from many modernlanguages, but high-quality interoperation with Objective-C was a primary concern: massive codebases weren't going to be rewritten overnight.

The Swift-Objective-C bridge has significant design impact on the language and significant engineering ramifications for anyone incrementally adopting Swift in anexisting project. This talk will address both topics.

First: what is the weight of the Objective-C bridge in Swift? How much complexity was added? Which elements disappear when Objective-C is not in use, and whichremain?

Then: a report from the trenches. We'll cover the features which caused the most impedance with a large existing codebase, approaches which permitted harmoniousgradual adoption, and the adoption benefits seen in practice.

Andy Matuschak (@andy_matuschak) - Khan Academy

Andy Matuschak leads mobile engineering at Khan Academy, where he's creating an educational content platform that's interactive, personalized, and discovery-based.Prior to that role, Andy helped build iOS 4.1-8 on the UIKit team at Apple, focusing on multitouch, rendering, and platform architecture. More broadly, he's interested insoftware architecture, computer graphics, epistemology, and interactive design. Andy and his boundless idealism live in San Francisco, primarily powered by pastries.

Cognitive Bias: A reflection and path forward

Date: 2015-09-26 14:30Room: Pepsi EncoreFormat: talkTrack: etc

Cognitive bias is one of the demons hiding in the dark when it comes to writing software. Your perception of situations can prevent you from being rational. In this talk,I'll visit examples of cognitive bias in the process of making software and present alternative views, which the viewer will amalgamate into future decision makingprocesses. The goal of this presentation is to reduce dogma, and make it easier to see how other points can be valid even when it offends your primal sensibilities.

Bryan Liles (@bryanl) - DigitalOcean

Bryan Liles works on strategic initiatives for DigitalOcean. In layman's terms, this means he writes OSS for DigitalOcean and others. Helps communities move theirsoftware to the public cloud, and gets to speak at conferences on topics ranging from Machine Learning to how build the next generation of developers. When not thinkingabout code, Bryan races cars in straight lines and around turns and builds robots and devices.

big-bang: the world, the universe, and the network in the programming language

Date: 2015-09-26 14:30Room: TheaterFormat: talkTrack: languages

How do you control communicating actors? How do you implement an SSH server in a truly functional style? How do you teach middle school students event-drivenprogramming? How are these questions related?

This talk will present a tour through Racket's world of thinking in a purely functional manner. It will start with the Universe library, which we use for reaching middleschool students, and it will end with a sketch of the Network Calculus dialect, a natural research outgrowth of the Universe.

Racket's Universe library is the foundation of the long-running Bootstrap and ProgramByDesign K-12 outreach projects. The library's exports make algebra come alive.With big-bang, a middle-school student's "hello world" program simulates a rocket lift-off:

(define (lift-off t)

(place-image rocket middle (- height t) background))

(define rocket .. some image ..) (define background .. some image ..) (define height (image-height background)) (define middle (/ (image-width background) 2))

;; run program run (animate lift-off)

More generally, middle school students can formulate interactive, graphical programs---animations, video games, or simple editors---with algebra. Even evaluating theseprograms uses nothing but algebraic calculations.

The key to this approach is big-bang, which turns algebraic functions on numbers, booleans, images, and strings into event handlers and rendering functions:

(big-bang height

[to-draw lift-off] [on-tick sub1] [stop-when zero?])

A big-bang expression describes a world with functions. Precisely put, it associates functions with certain events. Each function consumes the state of the world andpossibly some additional information; it returns the next state of the world or computes a property of the world.

Naturally a world is not enough. Therefore Universe also exports a universe form, with which students can create a network of worlds. For example, they can turn theabove animation into a remote-controlled one with just three lines of code added to the above:

[register LOCALHOST] [on-key (lambda (w key) (make-package w 'reset))] [on-receive (lambda (s m) height)]

A beginning student formulates the "universe" server as a top-level function instead of a lambda, but it still doesn't take more than 10 lines.

Even though worlds connected in a universe still consist of algebraic descriptions of state, state transformation, and communication, network connectivity turns theresulting systems into a non-deterministic one. Our college freshmen routinely study and use this material to construct distributed programs at the end of their firstsemester.

Finally, over the past couple of years, Universe programming has given rise to the idea of folding the network into the programming language. Here a network consists ofcommunicating actors---each of which may be a network itself---and a coordinating messaging board on which actors publish messages and subscribe to them.

The Network Calculus language (NC) is a dialect of Racket that supports programming with these trees of actors. As such, programming in NC resembles programmingwith actors in Akka or Erlang/OMP, but it also integrates well-known patterns as a language construct.

[[ Attendees are encouraged to install Racket before the presentation and to participate in a small interactive demo midway through the presentation (via pre-packagedcode). ]]

Matthias Felleisen

I launched the PLT research group at Rice University that created Racket and has maintained it for the past 20 years.

Cleaning the Tar: Using React within the Firefox Developer Tools

Date: 2015-09-26 15:40Room: Centene

Format: talkTrack: web

The Firefox Developer Tools have grown into something great, but as the codebase for the frontend has grown it has been difficult to manage complexity. This happenswith every project, so what do you do? The easy part is deciding on new abstractions; the hard part is migrating existing code to them.

Join me as I show you the secret workings of developer tools, the complexity of our frontend, and what we might do about it. I'll talk about how important it is to embracenew abstractions and how to slowly migrate large, complex codebases to them. I'll show how React is so helpful with these sorts of migrations. In addition, I'll explore allkinds of things we can do now that we are starting to use React.

I will explain the abstract concepts that React entails, primarily a pure functional UI, and explore various strategies for managing application state, like Flux, single atomapp states, immutable data structures, and Relay. I will apply these concepts to real examples and discuss advantages and disadvantages.

Lastly, we want working on our devtools to be delightful, so I will demonstrate how React enables this with hot reloading to see changes instantly while developing, andtime travel debugging.

James Long (@jlongster) - Mozilla

James Long works for Mozilla on the Firefox Developer Tools, mostly trying to make debugging JavaScript better. He's spent the last 8 years studying programminglanguages like Lisp and Scheme, and making apps for the web with JavaScript. He likes to write in-depth articles about interesting programming ideas. Most of his freetime is now happily dedicated to his daughter.

Evidence-Oriented Programming

Date: 2015-09-26 15:40Room: Midland States BankFormat: talkTrack: languages

Computer science has a long and complex history with programming languages. Historically, we have conducted evaluations using proofs, to ensure they give us theanswers we intend, and performance data, to ensure they perform efficiently. While these two techniques are well established and important, I argue a third isfundamentally missing from the design process: a scientific analysis of impact.

In the academic literature, for example, there is a near-complete lack of replicable scientific evidence regarding how the design of programming languages impacts peopleor communities, which has led in part to the programming language wars. In this talk, I introduce Quorum, the world's first Evidence-Oriented Programming language.Throughout it, I will discuss the specific evidence gathered on Quorum to-date and how other designers can use it to improve or evaluate their own products. Along theway, I will provide information on the history of evidence gathering through the centuries and why rigorous attention to the scientific method in this domain is crucial forthe future of computer science.

Andreas Stefik (@AndreasStefik) - University of Nevada, Las Vegas

Andreas Stefik is an assistant professor at the University of Nevada, Las Vegas. He completed his Ph.D. in computer science at Washington State University in 2008 andalso holds a bachelor's degree in music. Stefik's research focuses on computer programming languages and development environments, with an emphasis on howcompeting language designs impact people in practice. He won the 2011 Java Innovation Award for his work on the Sodbeans programming environment and is theinventor of the Quorum Programming Language. His work is funded predominately through the National Science Foundation, most recently through the AccessCS10kalliance.

JuMP: a modeling language for optimization inside Julia

Date: 2015-09-26 15:40Room: Peabody LoungeFormat: talkTrack: tools

"Algebraic modeling languages" (AMLs) are domain-specific languages (DSLs) for modeling optimization and constraint-satisfaction problems. They enable a user totranslate the mathematical statement of their problem to computer code in a natural way. There have been multiple standalone commercial AMLs that are very efficient (inboth the time to turn the model into solver input and in their modeling expressiveness), but they suffer from the difficulty of embedding them in a larger application.Multiple open-source AMLs, that are embedded in languages like Python and MATLAB, can be combined with other code but are often slow and can be inelegant.

In this talk we will discuss the properties and functionalities desired in an AML and how JuMP, a new AML implemented as a package for the Julia language, achievesthem. We begin be demonstrating examples of the optimization and prescriptive analytics problems that appear in a wide variety of domains, and show how they can beexpressed with JuMP. We describe how the "metaprogramming" functionality of Julia enables users to create a high-performance DSL like JuMP, and the benefits overalternative approaches such as operator overloading. We provide details about how JuMP uses metaprogramming not only to rewrite user code but to generate entirely newfunctions to calculate useful things like the functions gradients in a way that is transparent to the user. Finally we demonstrate how Julia, JuMP, Jupyter/IJulia notebooks,and Julia's packages for visualization and interactivity can be composed to help us to explore the results of an optimization problem in a way not previously possible, andto implement novel tools like a "travelling-salesperson-problem-solver"-as-a-service.

Iain Dunning (@iaindunning) - Massachusetts Institute of Technology

Iain Dunning is a PhD candidate in the Massachusetts Institute of Technology's Operations Research Center. His research focuses on the mathematics of how to makeoptimal data-driven decisions across time in the presence of uncertainty. He is a co-founder of the JuliaOpt organization, which develops and hosts a group ofoptimization-related packages for the Julia programming language. He also contributes to Julia itself, and is the maintainer of the Julia package ecosystem testinginfrastructure.

Relevance of ClojureScript

Date: 2015-09-26 15:40Room: Pepsi EncoreFormat: talk

Track: languages

ClojureScript is a compiler for the Clojure programming language that targets Javascript. One of ClojureScript's goals is to provide features that Javascript lacks. Some ofthese features are macros, concurrent programming and persistent data structures. With the release of ES6 and other Javascript advancements, one might ask "isClojureScript still relevant?".

In this talk, we will discuss how ClojureScript stacks up against ES6. Code examples in Javascript and ClojureScript will be demonstrated. At the end of the talk, anattendee will have enough information to make an informed decision about using ClojureScript.

Jearvon Dharrie (@jearvon) - Comcast

Jearvon Dharrie is a software engineer at Comcast. Jearvon spends his day working with Ruby, and the JVM. In his free time he enjoys toying with programminglanguages. He is currently interested in Clojure and ClojureScript.

Architectural Patterns of Resilient Distributed Systems

Date: 2015-09-26 15:40Room: TheaterFormat: talkTrack: distributed-systems

TBD

Ines Sombra (@randommood) - Fastly

Ines Sombra is an Engineer at @Fastly, where she spends her time helping the Web go faster. Ines holds an M.S. in Computology with an emphasis on Cheesy 80's RockBallads. She has a fondness for steak, fernet, and a pug named Gordo. In a previous life she was a Data Engineer.

Security for Humans: Privacy and Coercion Resistant Design

Date: 2015-09-26 16:30Room: TheaterFormat: keynoteTrack: keynote

TBD

Morgan Marquis-Boire (@headhntr) - Citizen Lab at the Munk School of Global Affairs, University of Toronto

Morgan Marquis-Boire is a Senior Researcher and Technical Advisor at the Citizen Lab at the Munk School of Global Affairs, University of Toronto. He is the Director ofSecurity for First Look Media and a contributing writer to The Intercept. Prior to this he worked on the security team at Google. He is a Special Advisor to the ElectronicFrontier Foundation in San Francisco and an Advisor to the United Nations Inter-regional Crime and Justice Research Institute. In addition to this, he serves as a memberof the Free Press Foundation technical advisory board. A native of New Zealand, he was one of the original founders of the KiwiCON hacker conference. His research onsurveillance and the digital targeting of activists and journalists has been featured in numerous print and online publications.