Emerging Technologies
for the Enterprise 2014

Jafar Husain - Tech Lead, Netflix

What’s does a mouse drag event have in common with an Array of numbers?

The answer to this question may surprise you: they are both collections. This key insight holds the key to dramatically simplifying asynchronous programming in Javascript. In this talk you will learn how you can use the familiar Javascript Array methods to create surprisingly expressive asynchronous programs. Using just a few functions, you will learn how to do the following:

• Declaratively build complex events out of simple events (ex. drag n’ drop)
• Coordinate and sequence multiple Ajax requests
• Reactively update UI’s in response to data changes
• Eliminate memory leaks caused by neglecting to unsubscribe from events
• Gracefully propagate and handle asynchronous exceptions

In this talk we’ll be exploring the Reactive Extensions (Rx) library (https://rx.codeplex.com/) which allows us to treat events as collections. You’ll learn about how Netflix uses Rx on the client and the server, allowing us to build end-to-end reactive systems. We’ll also contrast Rx with Promises, another popular approach to building asynchronous programs in Javascript.

Roland Kuhn - Project Lead, Akka

The game has changed: we write interactive web applications, we distribute the processing of huge data sets and our services need to be available at all times. This new breed of applications comes with its own set of requirements and forces us to establish new blueprints for designing our systems. In this talk we ask the crucial questions along this path, show which answers work and which don’t, and distill the essence of the common theme—Going Reactive.

Go Reactive: Blueprint for Future Applications

Brian Goetz - Java Language Architect, Oracle

The big language features for Java SE 8 are lambda expressions (closures) and default methods (formerly called defender methods or virtual extension methods). Adding closures to the language opens up a host of new expressive opportunities for applications and libraries, but how are they implemented? You might assume that lambda expressions are simply a more syntactically compact form of inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.

A. Bonnaire-Sergeant - creator, Typed Clojure

Typed Clojure is a gradual type system for Clojure and ClojureScript. In practice, type checking resembles “linting”: it is separate from compilation and must be called explicitly.

This has some interesting implications.

Instead of porting your old code to a “typed” variant of your language, you can gradually add type annotations and run the type checking function when needed; the checker will never stop your code from compiling normally.

However, we lose some of the more useful features most type systems enjoy, including the ability to transform code. This forces simpler optimisations that can be applied to any code.

By separating the type checker from the compiler, we also avoid infecting the rest of the language with the massive complexities of a static type system. Our compiler is simple and robust, our language design is unrestricted by an arbitrary type system, and our users are free to choose the right type system for the job.

We explore this idea further and demonstrate what such a type system is like to use.

David Nolen - contributor, Clojure core.async

The Model-View-Controller (MVC) approach to user interfaces was first
proposed by Trygve Reenskaug in a 1979 Xerox PARC note. As Object
Oriented methodologies gained popularity, MVC too gained traction as a
natural and logical way to construct user interfaces despite obvious
short comings. Even though OO researchers moved forward with
alternative approaches likes Morphic and constraint based systems, MVC
today maintains a strangehold on developer approaches to UI.

Can functional programming take the good lessons from MVC while
advancing the state of the art? Functional Reactive Programming and its
derivates primarily solve complexities around events – what of component
modularity and abstraction?

We’ll examine how a new library for ClojureScript called Om, a simple
functional layer over Facebook’s React, makes some traditional hard
problems in MVC based UIs simple without abandoning the abtractions OO
programmers find useful. These concepts are easily portable to other
systems provided the presence of persistent data structures.

The Functional Final Frontier

David A. Black - author, The Well-Grounded Rubyist
What is the essence of a programming language? How much can

it change before it isn’t itself? These are questions it’s unlikely
we’ll answer comprehensively in one talk: after all, “essence” is as
tricky a
philosophical concept as there is, and the Ship of Theseus—the ancient
paradox concerning the plank-by-plank rebuilding of a ship, and the
question of when the ship’s identity changes—remains a paradox. Still,
in practical terms, we’ve got some interesting things going on with
regard to Ruby: new implementations, para-implementations,
domain-specific implementations, and, in the face of all this
centrifugal activity, the
centripetal forces of RubySpec and ISO/IEC 30170. Is it going to come
down to speaking of “Rubies,” the way we speak of “LISPs”? Only time
will tell… but meanwhile let’s plunge into the Ruby landscape and
have a look around.

Chas Emerick - author, Clojure Programming

“Every system is a distributed system” has become a common catchphrase among distributed system theoreticians and distributed database vendors…and they’re right. What hasn’t become common are actionable discourse about what this concretely implies for real-world systems, and how it differs from the status quo. Drawing inspiration from and parallels with some of the lessons learned from our collective migration towards functional programming languages and data-orientation, I will attempt to provide part of one such discourse.

Dave Thomas - author, Pragmatic Programmer

The philosopher Wittgenstein believed that reality is bounded by our ability to express it: “the limits of my language mean the limits of my world.” Many others think along similar lines. I believe it is true when it comes to being able to express ourselves effectively.

In this talk I dig into the Elixir language—a functional language, inspired in part by the philosophy of Ruby, that runs on the Erlang VM. This isn’t a sales pitch for Elixir—there are dozens of great languages out there. Instead, I want to talk about how learning Elixir has changed the way I think about programming. And I want to encourage you to invest in your futures by developing new vocabularies and new reflexes.

Wittgenstein also said “what can be said at all can be said clearly, and what we cannot talk about we must pass over in silence.” I don’t know about you, but I’m not comfortable with the silence.

Evan Czaplicki - creator, Elm

Functional Reactive Programming (FRP) is a simple and elegant way to
design and structure interactive code, like games and GUIs. Elm is a
young functional language that brings this approach to the web,
allowing you to easily create complex interactions.

This talk will fully explain the key concepts of Functional Reactive
Programming, building up to live-coding to show these ideas in action.
It is pretty easy to integrate Elm into existing JS projects, but the
key insights of FRP will help you write better programs inany
language.