Keynotes
Programming for the Expression of Ideas
We think of computers and networks as compliant slaves that provide us with computational and communication power in the same way that a power shovel provides us with muscle power. Thus programming is thought of as a pragmatic tool for accomplishing useful work. A perhaps more unusual vision is that programming is a novel medium for the expression and investigation of ideas, in the same way that our natural languages and mathematics are expressive media.
I have pursued this alternative vision for most of my professional life. In many of the technical subjects that I teach at MIT it is easy to mechanically get the right answer without real understanding. To address this problem I use computer programs to communicate a deeper understanding of the material I teach. These programs are for the students to read as well as for a computer to execute.
I express the methods that I want students to learn as computational algorithms. Expressing the methods in a computer language forces them to be unambiguous and computationally effective. The task of formulating a method as a computer-executable program and debugging that program is a powerful exercise in the learning process. As a bonus, once formalized as a program, a mathematical idea becomes a tool that can be used directly to compute results.
I will illustrate this vision by showing how programming can help us to illuminate subjects like Analytical Mechanics and Differential Geometry. Programming can make some concepts of General Relativity come alive. Indeed, a well-crafted program is an expression of an idea, and it may be a work of art.
Gerald Jay Sussman - Massachusetts Institute of Technology
Gerald Jay Sussman is the Panasonic Professor of Electrical Engineering at the Massachusetts Institute of Technology. He received the S.B. and the Ph.D. degrees in mathematics from MIT in 1968 and 1973, respectively. Sussman is a coauthor (with Hal Abelson and Julie Sussman) of the MIT computer science textbook “Structure and Interpretation of Computer Programs”. Sussman’s contributions to Artificial Intelligence include problem solving by debugging almost-right plans, propagation of constraints applied to electrical circuit analysis and synthesis, dependency-based explanation and dependency-based backtracking, and various language structures for expressing problem-solving strategies. Sussman and his former student Guy L. Steele Jr. invented the Scheme programming language in 1975.
Systems that run forever self-heal and scale
How can we build large self-healing scalable systems?
In this talk I will outline the architectural principles needed for building scalable fault-tolerant systems. I'll talk about building systems from small isolated parallel components which communicate though well-defined protocols.
Programs will have errors in them and will fail so I'll talk about detecting and correcting errors at run-time. Programs will evolve with time, so I'll talk about how they be changed while they are running. I'll talk about Erlang and how it relates to these architectural principles.
Joe Armstrong is one of the inventors of Erlang. When at the Ericsson computer science lab in 1986, he was part of the team who designed and implemented the first version of Erlang. He has written several Erlang books including Programming Erlang Software for a Concurrent World. Joe held the first ever Erlang course and has taught Erlang to hundreds of programmers and held many lectures and keynotes describing the technology.
Joe has a PhD in computer science from the Royal Institute of Technology in Stockholm, Sweden and is an expert in the construction of fault tolerant systems. Joe was the chief software architect of the project which produced the Erlang OTP system. He has worked as an entrepreneur in one of the first Erlang startups (Bluetail) and has worked for 30 years in industry and research.
David Nolen (@swannodette) - The New York Times
David Nolen spends far too much of his free time having fun hacking on core.logic, core.match, and ClojureScript.
Sessions
Functional Mobile Applications in F#
Built around F#'s language-oriented features, WebSharper brings powerful functional concepts and composable abstractions such as formlets, flowlets and sitelets to solve many of the challenging problems of web development, and offers a uniquely productive framework to build robust, client-oriented web and web-based mobile applications.
In this talk, I will demonstrate how WebSharper's F#-to-JavaScript translation can be extended to cover native mobile functionality available through JavaScript libraries across a variety of mobile platforms, enabling F# developers to author Android, iOS, Windows Phone applications with pure F# code. The resulting applications are stunningly short and concise, utilize powerful functional ideas and F# metaprogramming capabilities, and reach millions of devices through simple packaging into native mobile code.
Adam Granicz (@granicz) - IntelliFactory
Adam is an F# MVP, and the co-author of four F# books, including Expert F# 3.0, the most comprehensive guide to the F# language, co-authored with Don Syme, the designer of the language. He is a long-standing member in the F# community with over eight years of experience in applying F# commercially and has led his software consultancy IntelliFactory to develop WebSharper, bringing unparalleled productivity to web development with F#. He is an active F# evangelist, a regular author in online F# media, and speaker at development conferences and industry partners. Adam serves on the steering committee of the Commercial Users of Functional Programming (CUFP) Workshop, where he represents the F# segment. He holds a Masters degree in Computer Science from the California Institute of Technology.
Simile-Free Monad Recipes
Most tutorials explain the whole monad burrito by first growing the wheat to make the tortilla. Metaphors can sometimes get in the way of the simple fact that most Haskell code boils down to five essential monads: IO, Reader, Writer, State and Error. The good news is they are easy to grok because the syntax is familiar and the semantics are already well understood by programmers of all stripes. This talk will focus simply on how to use them with no metaphors and simple code examples that do something useful. Attendees will leave the session knowing how to write real, useful apps in Haskell.
Aditya Siram (@deech)
Functional programming enthusiast, full-time Scala developer at Monsanto and wannabe Haskeller.
Functional Reactive Programming in the Netflix API
The Netflix API receives over two billion requests a day from more than 800 different devices ranging from gaming consoles like the PS3, XBox and Wii to set-top boxes, TVs and mobile devices such as Android and iOS.
As the unique demands of different devices have have diverged it became clear that the API needed to allow optimizing client-server interaction (http://techblog.netflix.com/2013/01/optimizing-netflix-api.html). We achieve this by enabling the creation of customized service endpoints that reduce network chatter, leverage server-side processing power and decentralize the development of each endpoint so as to encourage and empower rapid innovation.
This presentation will describe how the Netflix API achieves these goals using functional reactive programming using RxJava in a polyglot Java stack. Highly concurrent service endpoints are implemented without blocking, synchronization or thread-safety concerns by using declarative functional reactive composition. Parallelism and resiliency are enabled by the underlying Hystrix fault tolerance isolation layer that fronts the dozens of distributed systems within the Netflix SOA.
Ben Christensen (@benjchristensen) - Netflix
The Joy of Flying Robots with Clojure
Experience the joy of flying the Parrot AR Drone using the power of Clojure.
We will take a journey that begins with a child's dream of having a "real" robot friend. Along the way, we will discover the blessings of a functional language, the power of the Clojure language, the thrill of flying with a REPL, and maybe even gems of wisdom long lost under the snow of the AI Winter.
Carin Meier (@carinmeier) - Neo
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 a thing for Clojure and can be usually found with a cup of tea in her hand, hacking on her Roomba and AR Parrot Drone.
She builds software with the awesome folks at Neo in Cincinnati, where she also helps organize the Cincinnati Functional Programmers and Clojure Code and Coffee user groups.
Monads and Macros
The syntactic threading macros (-> and friends) hint at a whole new context for code that may be especially useful for network or other IO-related programs. Is it coincidence that the resulting code has a shape very much like state monad comprehension? We'll look at some code that can benefit from both approaches, weigh the benefits of each, and speculate about what could be done to make them better.
Chris Houser & Jonathan Claggett (@chrishouser) - lonocloud.com
Chouser has been a Clojure user and contributor since 2008. He currently writes in Clojure full time at LonoCloud, where he has been known to sometimes choose poor names for his functions.
Jonathan is a more recent Clojure convert whose fear of parens kept him in darkness for far too long. He also writes Clojure full time at LonoCloud and enjoys renaming Chouser's functions.
Functional composition
Music theory is one of the most naturally elegant and functional domains. It's a perfect fit for Clojure, which is why the Overtone audio environment makes hacking sound so much fun.
Chris will start with the basic building block of sound, the sine wave, and will gradually accumulate abstractions culminating in a canon by Johann Sebastian Bach.
By the end you should agree that anyone who's a developer is a musician too - even if they don't know it yet.
Chris Ford (@ctford) - ThoughtWorks
Chris Ford has been fascinated by functional programming since he first stumbled across Haskell during a misguided attempt to study electrical engineering. He came to his senses, and has spent the last six years happily coding in various countries across the world. He now lives in Kampala, working for ThoughtWorks Uganda.
Protocols, Functors and Type Classes
We will be taking a whirl-wind tour of the functional landscape, by looking at the concept of polymorphism through the lens of Clojure, Ocaml, Haskell and finally, Scala. We will follow a single problem through all these different languages finally landing in the hybrid world of Scala to see how these ideas were mapped into an OO world. If you are considering what language to choose for your next project or you are a language nerd like myself this presentation has a little for everyone.
Creighton Kirkendall (@crkirkendall) - System Evolution Inc.
Creighton Kirkendall has been building web application and leading development teams for over 17 years. Several years ago, Creighton fell in love with Clojure and has since teamed up with Carin Meier and few others to start the Cincinnati Functional Programmers Group (CincFP). These days his free time is spent, coaching soccer, developing in ClojureScript and chatting about the future of functional languages with anyone who will listen. Creighton works as an Architect/Developer at the awesome consulting company System Evolution Inc.
Living in a Post-Functional World
"Functional Programming" is the modern received wisdom regarding program and language design. All the cool kids talk about writing code that is "functional" or even "purely functional". However, functional programming as it is traditionally defined really doesn't cut the mustard, and if you look at how modern functional architectures are being shaped, everyone seems to have tacitly arrived at the same conclusion: more is needed. In this talk, we will look at how modern functional languages like Scala, Clojure and even Haskell have evolved beyond the simple paradigms of the lambda calculus. We will see how the industry has really moved beyond functional programming and into the realm of something more powerful, more expressive and better suited to the task of large application architecture.
Daniel Spiewak (@djspiewak) - Precog
Living in Big Data with Vector Functional Programming
This talk explores big data using vector functional programming. These languages enable rapid interactive development of concise and efficient applications. Vectors are a natural low impedance abstraction for dealing with high performance relational and NoSQL column stores. We use the k language and kdb+ database to illustrate the vector applicative style and idioms of FP through examples working efficiently with big data.
Vector languages are heavily used in finance and insurance for analysis of large time series. Vector/Array dynamic languages originated with APL family and include NIAL, J and k and databases such as Kdb+, MonetDB and Vectorwise. The have inspired array extensions in other general languages, such as Python NumPy and NamedTuple; and special purpose GPUs. Often these languages are considered high barrier languages because the compact notation and vector thinking require an investment to develop proficiently. Broaden your FP knowledge and understand the joy and power vector FP.
Dave Thomas - Bedarra Research Lab
Copious Data, the "Killer App" for Functional Programming
The world of Copious Data (permit me to avoid the overexposed term Big Data) is currently dominated by Apache Hadoop, a clean-room version of the MapReduce computing model and a distributed, (mostly) reliable file system invented at Google.
But the MapReduce computing model is hard to use. It's very course-grained and relatively inflexible. Translating many otherwise intuitive algorithms to MapReduce requires specialized expertise. The industry is already starting to look elsewhere…
However, the very name MapReduce tells us its roots, the core concepts of mapping and reducing familiar from Functional Programming. We'll discuss how to return MapReduce and Copious Data, in general, to its ideal place, rooted in FP. We'll discuss the core operations ("combinators") of FP that meet our requirements, finding the right granularity for modularity, myths of mutability and performance, and trends that are already moving us in the right direction. We'll see why the dominance of Java in Hadoop is harming progress.
You might think that concurrency is the "killer app" for FP and maybe you're right. I'll argue that Copious Data is just as important for driving FP into the mainstream. Actually, FP has a long tradition in data systems, but we've been calling it SQL…
Dean Wampler is a contributer to several open-source projects and the founder of the Chicago-Area Scala Enthusiasts. He is the author of Functional Programming for Java Developers, the co-author of [Programming Scala](http://programmingscala.com/), and the co-author of Programming Hive, all from O'Reilly. He pontificates on twitter, @deanwampler, and at polyglotprogramming.com.
Domain Specific Languages and Towers of Abstraction in Haskell
This talk will cover a range of techniques and use-cases for Domain Specific Languages, using Haskell. Using the JMacro library for programmatic generation of JavaScript, and the jmacro-rpc library for ajax interoperation between Haskell and JavaScript as a motivating example, it will discuss the space of representation and efficiency tradeoffs and design considerations in staged programming. The approach presented will focus on layering many "little" layers of abstractions, each providing semantic guarantees and conceptually serving as a target language for the next stage of design. It will attempt to demonstrate how techniques and research from the programming languages and compiler world provide accessible and convenient tools for those designing all sorts of libraries and APIs. There will also be some discussion of a second running example -- the adf-dfa library for compiling deterministic finite automata descriptions to LLVM. This will let us explore some other choices and approaches for a very different problem space, helping to highlight those issues that remain consistent, and those which are problem/domain specific.
Gershom Bazerman - S&P CapitalIQ
Functional Linear Data Structures in F#
This talk explores alternatives to the singly-linked list available from F# open source libraries for representing linear data. It investigates the characteristics of functional linear structures, the advantages of composition, using functional data structures in pattern matching, linear structures in composite functional structures like multiway trees, and applications to streaming data.
Jack's programming style has evolved through IBM System-370 assembler, COBOL (where it went retrograde), Cross System Product, Amiga REXX, VB6, and C# to functional programming using F#. Formerly a Director of Technical Operations at CoreLogic, he has worked as both a programmer and engineering manager on applications in a half dozen industries. He currently pays the bills hacking on SaaS applications and is an active contributor to fsharpx.
Functional Async Without the Pain
Distributed scalable asynchronous processing is often associated with the Actor Model, but the Actor Model is gigantic pile of side-effects and inversion of control. This session will present ways to use functional programming techniques and the new Async framework for Scala to regain compositionality while retaining the power of the model. We will explore ways to "scale up and out" while maintaining concision.
Jim Powers (@corruptmemory) - Typesafe
Jim Powers has been developing software for more than 30 years. During that time he's done a bunch of mainstream (C/C++/C#, Assembly, Java) programming to pay the bills but has always had a love of functional programming and programming languages. Spent much time over the years exploring Lisps, Haskell, ML, Miranda, Clean, and many others. Such beautiful languages and concepts - he despaired that it was all for naught. Fortunately, functional programming is in the midsts of a renaissance. For the last 3+ years he's been happily hacking in Scala at various startups including AOL where he was architect of the new version of Patch using Scala, Play and functional programming techniques. Today he works for Typesafe as an engineer on the Typesafe Console team.
Distributed Programming with Riak Core and Pipe
Riak Core has proven to be a robust distributed systems platform by leveraging Erlang, arguably the most pragmatic functional programming in widespread use. Riak Pipe offers a simple model for automatically distributing workload across a cluster. We'll discuss how each is used, within and beyond Basho.
John Daily (@macintux) - Basho Technologies
John Daily is continuing to chase a decades-long dream of doing full-time software development with detours through systems and network administration, global iOS mobile device management, and now technical evangelism for Basho. He has a passion for pragmatic programming languages, such as C, Perl, and Erlang. Beauty is definitely in the eye of the beholder.
QuickCheck: A Silver Bullet for testing?
- Are you tired of writing and maintaining thousands of automated tests?
- Are you tired of apologizing to your customers for unforseen (but not unforgiveable) product failures?
- Is testing just no longer any fun?
If the anwser is "Yes" to any or all of the above questions, then "QuickCheck" might be one solution for your woes. QuickCheck is a language and test tool whose purpose is to reduce testing time, reduce time to analyze the cause of failures, reduce testing costs, reduce volume of test code, and simply make testing fun. This talk will provide an introduction to Property Based Testing, share some real-life experiences from using QuickCheck, and highlight some resources on where to get started using QuickCheck.
Joseph Wayne Norton (@josephwnorton)
Joe Norton is a technical manager, system architect, developer, and Erlang/Scheme enthusiast. Based out of Tokyo, Japan, he has designed, developed, tested, deployed, and supported carrier grade Erlang/OTP-based messaging and storage systems.
Journey to the Heart of the For-Yield
Options and IOs and Iteratees, oh my! If you've poked around at Scala you've seen it--the ubiquitous for-comprehension sprinkled through idiomatic Scala code. As it turns out, what looks like a bit of syntactic sugar to ease prosaic list manipulation is actually a super powerful structure for abstracting away all kinds of common operations in a safe and maintainable way. It allows you to take full advantage of type safety and pushes the work of setting up boilerplate to the compiler. We'll break down exactly what's going on in a for-comprehension and explore some of the wild and wonderful structures that can be used within one. You'll leave with a deeper understanding of the possibilities of functional programming and plenty of real-world examples. Or, to put it another way:
for {
attendees <- thisTalk
you <- attendees.collect { case attendee: You => attendee }
yourFpKnowledge <- you.knowledgeOfFunctionalProgramming getOrElse beginner
} yield {
expand(yourFpKnowledge)
}
Kelsey Innis (@kelseyinnis) - Reverb
Kelsey Innis strives to write code with charisma, uniqueness, nerve and talent and hopes to one day really, truly, deeply understand what a monad is.
Enabling Microservice Architectures with Scala
Over the past 4 years, the production architecture at the Gilt Groupe (www.gilt.com) has evolved from a single monolithic web application to a highly-distributed collection of more than 200 micro-services and small web applications. This architectural shift allows greater scalability and faster, less coupled development of new features, but also presents challenges around maintaining consistent development, testing, and deployment processes. We've developed a number of techniques for addressing these challenges and implementing new features using our preferred language of Scala.
This experience report will discuss some of the interesting and novel ways we make use of Scala including:
- Creating an SBT uber-plugin to abstract and unify the development process with testing, deployment, and operations
- Using the cake pattern to bridge the divide between unit testing and functional testing
- Type-safe shared configuration using Zookeeper
- Live inventory updates using Play WebSockets and Akka Actors
Kevin Scaldeferri (@kscaldef) - Gilt Groupe
Kevin Scaldeferri is a software developer specializing in scalable, high-performance server applications. He spent several years at Yahoo building ad serving systems, and currently works at Gilt Groupe, where he has worked on the core e-commerce and order processing components, as well as development tools, infrastructure, and architecture. He has spoken at OSCON, YAPC, several user groups, and given internal tech talks on a variety of topics such as "How to Serve a Billion Requests a Day with Perl", "Beautiful Concurrency with Erlang", SBT, Continuous Deployment strategies, and more.
Finite State Machines - Why the fear?
Finite State Machines are overlooked at best, ignored at worst, and virtually always dismissed. This is tragic since FSMs are not just about Door Locks (the most commonly used example). On the contrary, these FSMs are invaluable in clearly defining communication protocols - ranging from low-level web-services through complex telephony application to reliable interactions between loosely-coupled systems. Properly using them can _significantly_ enhance the stability and reliability of your systems.
Join me as I take you through a crash-course in FSMs, using erlang's _gen_fsm_ behavior as the background, and hopefully leaving you with a better appreciation of both FSM and erlang in the process.
Mahesh Paolini-Subramanya (@dieswaytoofast) - Ubiquiti Networks
I've been involved in 'Internet Stuff' since Day Zero (remember Gopher?), and currently as V.P. of R&D at Ubiquity Networks, am building out massively concurrent Erlang based systems and services.
I have the - dubious - honor of being involved in creating the first web/e-commerce system, the first java based financial service, as well as the first erlang-based cloud PBX, three projects I may never live down.
I have a Bachelor's degree is from the Indian Institute of Technology, Kanpur, and a Masters from the University of Notre Dame.
Functional I/O in Scala
IO is usually quite hard to tackle in a functional way. The predominant paradigm for I/O is the cursor. A cursor is a data structure that holds the current state of an I/O resource and provides a function to retrieve the next data available from that resource. This approach lacks some very properties we functional programmers care about:
- composability - Writing explicit I/O loops makes to hard to compose
- not functional - Ideally we write functions that transform input to output but pull based I/O (where you read the chunks) makes it hard to write pure functions
There are already libraries that provides some abstraction to overcome these shortcomings but somehow lacks in composability. In this presentation I will explore Enumeration based I/O with iteratee and how that makes I/O operations both functional and efficient. I will take some real world example use cases using Play framework where this approach has been used with success.
Nilanjan Raychaudhuri (@nraychaudhuri) - Typesafe Inc.
Lisp and Cancer
The human being is one of the most complicated machines in existence. When things go wrong, they go really wrong, and in order to figure out the solutions only the most powerful technology will be sufficient. Based on over a year of applying Clojure, Neo4j and domain specific languages to the problem of cancer, this presentation details some of the solutions we arrived at and also some of the lessons learned.
Ola Bini (@olabini) - ThoughtWorks
Clarity of Intent: Three Features of F# Which Lead to Better Code
Source code tends to be read (by humans and machines alike) more often than it is written. So, it makes sense that code should be as clear and direct as possible. In this talk, suitable for all skill levels, we will review three simple features of F# (two of them uncommon in most languages) which can lead to more focused, precise, and readable code. Specifically, we will see how the combination of pattern decomposition, active recognizers, and unit-of-measure annotations dramatically increase the clarity of an author's intentions. In particular, we will see how doing so actually reduces code footprint while increasing maintainability.
Paulmichael Blasucci (@pblasucci)
Paulmichael Blasucci is a research at Bayar Rock. As a passionate – yet pragmatic – functional programming enthusiast, he has spent the past six years employing a "functional-first" methodology to develop compelling solutions to a wide range of business problems. He especially enjoys solving challenges in distributed computing, applied linguistics, and heterogeneous enterprise systems.
Functional CoffeeScript for Web UIs
You love building Web UIs but don't love bloated JavaScript. Rocking CoffeeScript with functional programming lets you pack a ton of logic into concise, composable, readable code. This talk will show how JavaScript developers of all backgrounds can benefit from functional programming with CoffeeScript's implicit returns, pervasive expressions, and concise function declarations. Come see how you can use Functional CoffeeScript to transform a tangled UI codebase into something shorter, simpler, and easier to reuse. Make functional programming in the browser a pleasure!
Richard has been lovingly crafting user interfaces since he was nine. Since then he's built software for audiences as varied as gamers, scientists, students, novelists, and hospital patients. He's passionate about the Web and has shipped production CoffeeScript for fun, for startups of varying sizes, and for Fortune 500 companies alike. He lives in St. Louis, MO with his awesome wife, friendly dog, and mischievous cats.
Redex: Program Your Semantics
Redex is a domain-specific programming language for writing down operational semantics---meaning you can, in just a few lines, write down a complete running version of the lambda calculus and, in just a few more, add in enough to build a core of your favorite programming language. Redex also provides tool support for falsifying claims about the semantics---meaning you can, in just a few lines, automatically find bugs in your semantics.
This talk will introduce and motivate Redex and work though some examples in a hands-on way, showing how to exploit Redex's tool support to eliminate bugs from your semantics and generally learn more about the programming languages you use everyday.
Robby Findler - Northwestern University
Robby Findler is one of the core developers of Racket, focusing primarily on Racket's IDE, DrRacket. His day job is as a programming languages researcher at Northwestern University where he works on software contracts, operational semantics, and language design.
Addressing Network Congestion in Riak Clusters
In high-scale distributed systems like Riak, an open source distributed database written in Erlang, the network can make or break system reliability and availability. In this talk, Steve will discuss an experimental approach to alleviating network congestion effects such as timeouts and throughput collapse for Riak clusters under extreme load. In addition to exploring network scalability issues, this talk shows how Erlang can seamlessly integrate with non-FP languages, particularly C++ and C. Attendees need not have any Erlang experience or Riak experience, as the presentation provides brief introductions to both.
Steve Vinoski (@stevevinoski) - Basho Technologies
Data, Visibility, and Abstraction
One reason programming is hard is because it is so difficult to observe what is happening when a program runs. Programming languages and libraries rely on abstractions which either hide important details or produce too much information to consume. Developers come to depend on ever-more-sophisticated tools to examine programs and diagnose failures. However, with a little care and design, it is possible to build systems which lend themselves to easier comprehension. This talk will introduce some general guidelines for designing systems which make their data and abstractions more transparent to developers, using code examples in Clojure.
Stuart Sierra (@stuartsierra) - Relevance, Inc.
Stuart Sierra is a developer at Relevance, Inc., a member of Clojure/core, and the co-author of "Practical Clojure" (Apress, 2010) and "ClojureScript: Up and Running" (O'Reilly, 2012). He has been involved with many open-source technologies including Clojure, ClojureScript, Ruby on Rails, Hadoop, and Solr.
Semantics, clarity, and notation: the benefits of expressions over statements
We need to understand our programs, to know they fit the circumstances where we use them. Whether we can reason about programs is limited not just by how complex they are but by how complex they seem, which depends on their representation.
In this session I'll explore what we gain by putting special attention to meaning. We'll see how a mathematical attitude toward notation helps expose important details, and hides unimportant details. As a lifeline, lest we drown in deep abstractions, we'll keep our grasp on contrasts between expressions and statements. Expressions and statements will be tied to different models of computation. The advantages of mathematical models will be brought out through expressions involving function composition. The difficulties of understanding programs through an operational model will be shown through the relationship between statements and state-mutation.
While lambda-calculus has been the springboard for most expression-oriented languages, most of my examples will be given in the J programming language, which draws instead on combinatory logic.
A preference for expressions over statements is mnemonic for a broader appreciation for modeling programs as articles of mathematics, rather than by machine operations. Behind this lies a sense of the beauty of "pure" or "denotative" programs. This aesthetic is practical: only insofar as programs fit this model can they be simple enough for us to comprehend. Software is reliable when it is correct, so excitement about purity contributes toward correctness even in (normal) environments that make it hard.
Tracy started programming on teletypes at his high-school. The subsequent world of work filled some years with programming, some with other tasks. Though mostly involved with small business, he's worked at big corps including Apple, BPX, and Symantec. Tracy accidentally became known an advocate for the J programming language, and wonders whether J might be a mind-parasite. Relax; if J is a mind-parasite it can't be highly contagious.
Let It Crash: Erlang Fault Tolerance
Erlang is well known for its concurrency, distribution and beautiful syntax. Many languages and frameworks have come on the scene recently that people attempt to compare against Erlang's performance and concurrency. While concurrency is important, what is missing from the discussoin is Erlang's possibly most important feature, its inclusion of implicit fault tolerance in its design.
In this presentation you'll learn what sets Erlang apart from the pack when it comes to building large fault tolerant systems, as well as discuss patterns useful across languages. We will work from the bottom to the top, starting with the language itself's design decisions and features such as monitoring and linking of processes, up to the OTP middleware which provides robust components for building and supervising complex concurrent systems.
Tristan Sloughter (@t_sloughter) - Heroku
Tristan Sloughter is an experienced Erlanger who is a member of the Erlware project and was an organizer/speaker at 2010 ErlangCamp. He currently works on the routing and logging layer of Heroku's PaaS that has enabled hundreds of thousands of developers to build and deploy more than two million applications.
Workshops
Try F# from Zero to Data Science!
In this tutorial, Rachel will introduce you to the Try F# samples giving you exposure to, and an understanding of, how F# tackles some real-world scenarios. She'll start with some syntax basics, continue through currying and computation expressions, and head for type providers and data visualization. Along the way, she'll help you explore, generate, and just play around with code samples, as well as talk you through some of the key principles of F#. By the end of this session, you'll have gone from zero to data science in only a few hours!
Rachel Reese is a long-time software engineer and math geek who has recently relocated to the lovely Burlington, Vermont. She runs the local functional programming user group, @VTFun, which is a constant source of inspiration to her, and at which she often speaks on F#. She's also an ASPInsider, a community enthusiast, a founding member of LambdaLadies, and a Rachii. You can find her on twitter, @rachelreese, or on her blog: rachelree.se.
The Art of Several Interpreters, Quickly
We briefly review a small subset of Scheme, and then show how using this, you can in short order build an interpreter for the lambda calculus. We then, in a step-by-step manner, extend our interpreter with a store and an explicit continuation, and add forms to the language that allow us to implement several new features. By the end you will have all the tools needed to build your own interpreter for a language with dynamic scope, side-effects, and control operators.
Daniel P. Friedman, Jason Hemann (@dfried00 @jhemann)
Daniel P. Friedman is Professor of Computer Science at Indiana University. He is co-author of The Little Schemer, The Seasoned Schemer, The Reasoned Schemer, The Little MLer, A Little Java: A Few Patterns, Scheme and the Art of Programming, and Essentials of Programming Languages, 3rd Edition, all published by MIT Press.
Jason Hemann is a third-year doctoral student at Indiana University specializing in programming languages. His interests include functional and constraint-logic programming. He is currently an Associate Instructor for the Programming Languages course at Indiana University.
Hands-on Intro to Haskell
It's a hands-on workshop but you won't have to install any software. You'll be programming in your browser using the compiler in the cloud.
We'll start with some Haskell syntax so you'll be able to read Haskell code, then proceed with simple functions, data structures, pattern matching, etc. Finally we'll talk about the most interesting topic -- monads.
Bartosz Milewski (@bartoszmilewski) - FP Complete
Bartosz used to be a physicist (he has a Ph.D. in Quantum Physics) but he fell in love with programming and joined Microsoft as the development lead of the Content Index team -- the search engine before the Internet. Whenever you do a file search on Windows, you're running his code.
After Microsoft, Bartosz started his own company, Reliable Software, where he designed and helped implement the first peer-to-peer version control system, Code Co-op, which is still in commercial use.
He became an expert in C++ and published the book C++ In Action. He is best known for his blog, where he discusses topics in concurrency, parallelism, language design, functional programming, and many other areas. He attended one C++ Standard Committee meeting on concurrency and decided that C++ was too far behind Haskell, or even C#, in this area. He's a frequent speaker at professional conferences on topics ranging from multicore architectures to implementing Haskell monads across languages.
Top-Down Test-Driven Design in Clojure
In the object-oriented world, there are two main styles for test-driven design. The "Detroit style" codes bottom-up from leaves of the program's dependency graph. The "London Style" codes top-down (or outside-in), using mock objects to define and explore dependencies that don't exist yet. Both styles are highly iterative and focus on building just-good-enough-for-the-current-requirements paths through a final dependency graph. Nevertheless, they are distinct styles, with distinct concerns.
The London Style is best described by Freeman and Pryce's /Growing Object-Oriented Software: Driven By Tests/. This workshop will explore what a top-down style would be like in a functional language where the unit-of-dependency is not the class but the function.
The workshop will not focus on the mostly-cultural conflict between programming driven by tests and "repl-driven development", but it might well clarify the concerns that lead to each style - and it might show how the two can be merged.
Participants will work in pairs. At least one of the pair should have a Clojure development environment that includes Leiningen.
Brian Marick was a Lisp and C programmer in the 80's, a testing consultant in the 90's, and an Agile consultant in the 00's. This decade he's a Clojure and Ruby programmer. He was one of the authors of the Manifesto for Agile Software Development and is the author of four books, /The Craft of Software Testing/, /Everyday Scripting with Ruby/, /Programming Cocoa with Ruby/, and /Functional Programming for the Object-Oriented Programmer/.
The Seductions of Scala
I was seduced by the Scala language several years ago. This hands-on workshop will show you why. We'll see how Scala blends the best of Functional and Object-Oriented Programming. The FP support provides powerful tools for data transformation and analysis, and for building distributed systems. The OOP support fixes problems with Java's object model, greatly improving modularity. You eliminate code bloat and you get a nice platform for creating Domain Specific Languages (DSLs). Finally, Scala is similar enough to Java that busy Java programmers can start using it without a step learning curve.
Dean Wampler (@deanwampler) - Think Big Analytics
Dean Wampler is a Principal Consultant for Think Big Analytics, specialists in "Big Data" application development, primarily using Hadoop-related technologies. Dean is a contributer to several open-source projects and the founder of the Chicago-Area Scala Enthusiasts. He is the author of "Functional Programming for Java Developers", the co-author of "Programming Scala", and the co-author of "Programming Hive", all from O'Reilly. He pontificates on twitter, @deanwampler, and at polyglotprogramming.com.
F# on the Web
Microsoft's F# language offers a new level of productivity to developers on the .NET platform. Unfortunately, most businesses have a hard time understanding where F# fits into their existing platforms. Dan and Ryan will work through the transition from an existing ASP.NET application to a F#-based solution that converts all the server and most of the client code, as well as the build scripts and Azure services code to F#. Along the way, they'll demonstrate several additional features of the F# language such as units of measure and type providers.
This workshop targets those developers who are relatively new to functional programming, specifically on the .NET and Mono platforms. However, many of the concepts are generally applicable to functional programming in general.
Ryan Riley and Daniel Mohl (@panesofglass) - Catapult Systems, Inc.
Program Transformations
We'll guide you in writing your own Scheme-to-C translator by demystifying the program transformations that make a higher-order functional program run on a spartan host. You'll learn about continuation-passing style, representation independence, registerization, and trampolining. We first illustrate the program transformations step-by-step on some Scheme programs, and then challenge you to automate the steps!
William E. Byrd and Nada Amin (@webyrd @nadamin)
William E. Byrd is a Postdoctoral Researcher in the School of Computing at the University of Utah. He is co-author of The Reasoned Schemer, and co-designer of several declarative languages: miniKanren (logic programing), Harlan (GPU programming), and Kanor (cluster programming). His StarCraft 2 handle is 'Rojex' (character code 715).
Nada Amin is a PhD student at EPFL, advised by Martin Odersky. Previously, she was a software engineer at Google, in the Gmail and Closure compiler teams. She holds bachelor and master degrees in Computer Science from the Massachusetts Institute of Technology, where she tutored "Structure and Interpretation of Computer Programs" as a lab assistant.
Uses Lenses, Folds and Traversals
In Haskell we have many very useful abstract classes such as Functor, Foldable, Traversable and functions, and we have many types that offer instances for some or all of these classes, but working with compositions of them can be clumsy. Working with monomorphic containers such ByteString or IntSet can be painful and "un-Haskelly" because you wind up having to import a completely separate API for working with just that type. Working in deeply nested structures can be painful because record syntax is not compositional, and much of the power inherent in the imperative programming language concept of just accessing member variables directly is lost in an immutable world.
The lens library provides a common vocabulary that resolves each of these issues and many more besides. We'll dive into enough of the theoretical underpinnings to understand how lenses hold together and then turn toward how they can be used to make it easier to both write and reason about your software.
Edward A. Kmett (@kmett) - S&P Capital IQ
Edward discovered Haskell in 2006 after many years of writing compilers for toy imperative languages that somehow all looked like a mishmash of Perl, Python and C++. Upon realizing the error of his ways and after briefly flirting with dependent and substructural type systems he switched to Haskell and ever since has sought to make up for his past crimes by giving back to the community. He currently maintains more Haskell packages than anyone, sits on the haskell.org committee, organizes Boston Haskell, has managed the Google Summer of Code for the Haskell community for the last 4 years, is the 5th most active user on github, and doesn't sleep much.
Functional Web Development with Clojure
Web development is normally messy, complicated, and chock-full of side effects. Can we use functional programming for the real world of web development and eliminate the usual morass of 4 different languages (minimum) you have to use to make a dynamic web application?
I say we can. I am going to demonstrate how in Clojure, a pragmatic functional language, but the techniques should be useful in any functional language. We'll use one language to build our entire application, using the same side-effect-free functions on the front end and back end. Along the way, we'll learn about functional-reactive programming and how that can make creating web user interfaces much less painful.
Clinton N Dreisbach (@cndreisbach) - Consumer Financial Protection Bureau
Building Applications In Erlang
Despite the simplicity of the language, programmers can use Erlang to build remarkably sophisticated, complex applications! But how?
This hands on workshop will walk you through the process of creating a typical Erlang application. It's not as hard as it may seem. We'll start with trivial functionality and incrementally evolve the code over three hours -- at each step adding features and demonstrating Erlang programming techniques.
If you're new to Erlang or want to learn more about building applications with the language, this workshop will get you up to speed in just a few hours. From there, you'll be able to tackle basic projects on your own -- and count Erlang among the tools in your programmer's toolbox!
Garrett Smith (@gar1t) - CloudBees
Garrett Smith is programmer at CloudBees, the leading Java platform-as-a-service vendor, where he directs the use of Erlang to manage platform services and infrastructure. He has over 20 years development experience and specializes in distributed systems and reliable software. Garrett organizes the Chicago Erlang User Group and an occasionally teaches Erlang classes. He's the author of the e2, an Erlang library that simplifies the process of writing correct OTP applications. He's the creator of MongoDB Is Web Scale and Node.js Is Bad Ass Rock Star Tech.
Installed to Productive in Julia: A Multiple-Dispatch-Oriented Functional Language
Julia is a high-level, high-performance dynamic functional language. Programs are organized in a functional style; development workflows center on the REPL; types are flexible, useful, and dynamic; syntax is clean and familiar. Where languages like OCaml and Haskell can feel filled with challenging ideas and focused on ideological concerns, Julia feels as practical and easy to learn and use as Python.
The workshop will cover Julia basics, such as syntax, development workflow, features of the REPL, and places to find documentation and assistance. Effective uses of multiple dispatch and the dynamic type system in program design will be highlighted. Specific features, such as the mechanics of running shell commands, interfacing with C, writing macros, and using coroutines will be covered. Julia is mostly written in Julia, so code examples will be sourced from the core Julia codebase.
Attendees will be expected to have Julia already installed, as there will be hands-on exercises.
Leah is a programmer with an interest in lesser-known languages and technologies – Rust, Julia, and the Haiku operating system. A summer writing OCaml as an intern at Jane Street completely convinced her of the value and practicality of functional programming. She's since fallen in love with Julia and wrote the websockets implementation for Webstack.jl.
Leah was a student in Hacker School's Winter 2013 batch. She holds a BS in Computer Science from Johns Hopkins University.
Macros!
The main feature of Clojure and other lisps that jump out to most people is all those parentheses. In this workshop we'll put them to good use by exploring what they enable – sophisticated macros for compile-time programming. We'll introduce the the basic concepts of lisp macros, Clojure's tools for creating them, and work through a series of increasingly sophisticated exercises, building macro-writing skills and learning best practices for when, and when not, to use them.
Drew Colthorp (@dcolthorp) - Atomic Object
Drew makes great software at Atomic Object.
Compilers From Scratch
Compilers are central in every programmer's kit of tools, but to many they remain mysterious black boxes that consume source code and produce executable programs. Although compilers can be extremely sophisticated and complicated pieces of software they do not need to be impenetrable to understanding. Furthermore even a basic understanding of the traditional compiler pipeline can aid tremendously in better understanding the inner workings of any programming language.
During this workshop we will gain a better understanding of the workings of a compiler by implementing one for a simple language from scratch. We will first examine a basic implementation of Regular Expressions and use them to implement a Lexical Analyzer for our language. Next we will discuss implementations of Parsers and Parser Combinators in functional languages and use these to build a Parser for our language and generate an Abstract Syntax Tree.
After lexing and parsing the syntax of our language, we will analyze the options we have to deal with the Abstract Syntax Tree including both interpretation and compilation. From here we will discuss topics such as basic type checking, and generating machine code from the Abstract Syntax Tree. To avoid the complications of a real machine language we will generate machine code for a Virtual Machine such as the SECD machine, G machine, or CESK machine that will be discussed in detail in the workshop. If time allows we will further examine how the techniques we have developed can be used to analyze and implement imperative languages in a functional setting.
I am an amateur functional programmer and aspiring graduate student from Anchorage Alaska with a strong interest in the design and implementation of programming languages. I spend most of my time volunteering with a local high school robotics team coordinating fundraising efforts and teaching programming to high school students. Other times I can be found speaking at local meetups about programming languages, compilers, and robotics.
Functional Web Applications with Webmachine
Webmachine is a system for easily and declaratively building well-behaved HTTP applications. It is based on a very different execution model than most frameworks, with sets of resources defined by collections of functional predicates over those resources. This approach makes it easy to focus on writing the core of your application and also helps you to get the harder parts of HTTP right.
This workshop will guide the attendee through understanding and getting started with Webmachine, gradually exposing richer HTTP features while building out an application that is used by browsers and API clients alike. Knowledge of Erlang is not necessary for this workshop, but experience with a functional language is recommended.
Sean Cribbs, Chris Meiklejohn (@seancribbs @cmeik) - Basho Technologies
Sean Cribbs is a Software Engineer at Basho Technologies, where he hacks on Riak, the fault-tolerant, highly-scalable distributed database. Prior to Basho, Sean was a freelance developer and consultant who also managed the development of the open-source Radiant web publishing system.
Christopher Meiklejohn is a Software Engineer with Basho Technologies, Inc. where he focuses on building rich web applications for Riak using Erlang and JavaScript. Before joining Basho, he worked at Swipely, a loyalty program startup based in Providence where he maintained critical infrastructure components written in Ruby. Christopher currently serves as one of the maintainers of Rubygems.org.
Introduction to Summingbird
Summingbird is a library that allows the user to deploy a mapreduce-style workflow on either a Hadoop cluster (for batch processing), a Storm cluster (for realtime processing) or both. Summingbird also provides a client that can merge data generated in offline and online mode into a single, aggregate realtime dataset. This is, in some sense, an implementation of the ideas in Nathan Marz's Big Data book, but running at scale inside of Twitter with all the kinks ironed out.
This workshop will introduce participants to Summingbird with a project template and a series of exercises designed to get users started writing more complex Summingbird jobs. The goal of the workshop is to provide every participant with the skill necessary to apply Summingbird to relevant problems in their own fields.
Sam Ritchie (@sritchie) - Twitter Inc
Jam Mentors
Mathias Brandewinder (@brandewinder)
I have been developing in .NET for nearly 10 years, came across F# a couple of years ago, and fell in love with it. I enjoy arguing about code and how to make it better, and get very excited when discussing TDD or F#. My other professional interests are applied math, probability, and how to use them to make better business decisions. I am a Microsoft MVP for F#, and run the .NET and F# user groups in San Francisco.
Paulmichael Blasucci (@pblasucci)
Paulmichael Blasucci is a research at Bayar Rock. As a passionate – yet pragmatic – functional programming enthusiast, he has spent the past six years employing a “functional-first” methodology to develop compelling solutions to a wide range of business problems. He especially enjoys solving challenges in distributed computing, applied linguistics, and heterogeneous enterprise systems.
Travis Vachon (@tvachon)
Travis has been public with his love affair for functional programming for years. Hooked by Python's first class functions, he spent a few years in the minimalist/surrealist landscape of JavaScript before falling in love nearly simultaneously with Scala and Clojure. Occasional flirtations with Erlang and Haskell aside, he spends much of his professional life at Copious (a people-oriented marketplace) using Clojure to build real time activity stream processing systems, work he presented at the 2012 Clojure Conj. In his off time he is known for flogging Clojure relentlessly as an organizer of the local Ithaca Web People meetup and Open Hack session. He has facilitated the Ithaca Global Day of Coderetreat where he was delighted to see working programmers applying functional techniques in their off time.
Chris Ford (@ctford)
Chris Ford has been fascinated by functional programming since he first stumbled across Haskell during a misguided attempt to study electrical engineering. He came to his senses, and has spent the last six years happily coding in various countries across the world. He now lives in Kampala, working for ThoughtWorks Uganda.
Eric Normand (@ericnormand)
Eric Normand is from New Orleans. He programs in Haskell professionally but is seeing Clojure on the side. He has been programming in Lisp since college, way back in 2001. He switched to Clojure in 2008 and has not looked back. You can find him online writing on LispCast, his newsletter the Clojure Gazette, and making educational videos about Clojure (also called LispCast).