Emerging Technologies
for the Enterprise 2014

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

Michael Bryzek - CTO & Co-founder, Gilt Groupe

We built and scaled Gilt by building an environment where great engineers can create amazing things.
This talk is a reflection on what we have learned along the journey from startup to one of the leading ecommerce companies. We start with a baseline of behavioral psychology – and reflect on the decisions we made and tradeoffs we considered as we scaled, with an in-depth look at the benefits and challenges of a micro-services architecture.

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.

Jim Benson - creator, Personal Kanban

Software development requires focus, direction, and understanding: three things most software teams rarely enjoy. To build better software, we’ve tried to protect teams, to integrate teams, to elevate teams. We focus on the team, but not the individual coder. We focus on the team, but not the individual manager. We focus on the team, but not the individual ops person. We focus on team team team, but not the people on the team.

Since software is not created by machines, but by people – doesn’t it make sense to pay attention to the people? Universally, people in the industry are overloaded, distracted, and stressed.

Stress Sucks. This stress is where technical debt is born. This is where unnecessary features are released. This is where integration issues are inevitable.

In this talk, Jim Benson will tell painfully funny stories (because they’re all true) about teams of wonderful people who built terrible products, simply because they were focused on the object of value at the expense of who produced it. They were focused on process and not people. They were focused on their task-at-hand and not on what their peers were actually working on.

And … he’ll give specific and tested recommendations to cure this pandemic of overload.

Jim Benson promises a powerpoint-free presentation.

Greg Young - Originator of CQRS

We are forced to solve many problems with respect to handling data. Many concepts work in our current models, many do not. Picking the wrong model can lead to massive amounts of accidental complexity.
“Polyglot data” should not be confused with “polyglot persistence.” The former refers to using multiple data representations in a single system (ie OLAP, Graph, Lucene, CEP…). Choosing ElasticSearch or
Command Sourcing with a CQRS implementation is different than choosing Redis for caching or Mongo for unstructured data. This talk will look at how to reach the point where you stop thinking about how to force
your problem into your predefined thinking and how to reach a place where you focus on how to choose the right model for the problem!

James Wanga - Morgan Stanley

AngularJS directives are a powerful tool that can bring elegance to complex technologies like WebGL. Last year, with an amazing team, I won a NASA hackathon by building a drone using a quad-coptor and a
custom built sonar that was later featured on the discovery channel. During my talk I’ll walk through how that project has evolved into an example of how we can use AngularJS directives and services to interact with the physical world in beautiful ways, unbinding this excellent framework from the browser.

Angular Reality: Rendering the World in Real Time with AngularJS Directives and WebGL

Burin Asavesna - javascript, ruby, mobile, user experience, texas!

This is a talk sharing TripCase’s (http://phonegap.com/app/tripcase/) experience with (and without) PhoneGap Build. We’ll walk through our journey and discuss how it shaped expectations on how quickly we should be getting our code in the hands of fellow testers and stakeholders.

Ben Alman - creator, Grunt

As web applications have become more complex, we’ve addressed performance, usability and scaling concerns by promoting JavaScript from second-class citizen (image rollovers, form validation) to first-class citizen (business logic, app routing, Ajax, templating). However, in doing so, most of us haven’t optimized our process to treat JavaScript and its front-end siblings, CSS and HTML, like the first-class parts of our application that they have become. In this talk, we’re going to learn how to incorporate Grunt: The JavaScript Task Runner into our build process to help automate often-marginalized tasks that center on the “Front Half” of your app (you know, the half of your app you take for granted).

Kyle Kingsbury - creator, Jepsen

We rely on distributed databases and queues to store and process data reliably, but many fall short of their marketing promises. I’ve spent the last year building tools to stress and analyze popular databases
during network partitions, uncovering everything from undocumented behavior to catastrophic data loss. In this installment of the Jepsen project, we’ll explore what “strongly consistent” really means, and
find out whether various databases live up to their claims.

Diana Larsen - co-author, Agile Retrospective: Making Good Teams Great

Going “Agile” can confer a number of benefits to teams and organizations, but all too often those promised benefits aren’t fully delivered and everyone wonders why. As organizational leaders/mentors and Agile coaches, we find ourselves confronted when the promise of Agile doesn’t match the reality. How do we avoid the traps of “ScrumBut” or “FragileAgile” in a better way? How do we help teams and leaders ask the right questions and make the right investments? The “Path Through Agile Fluency” model of the predictable signs of agile team competency can help. Through the lens of Agile Fluency coaches help leaders define the benefits they’re getting from their current flavor of Agile, determine the benefits they really want from team effort, plan next steps, and describe success. Join Diana Larsen in an exploration of ways coaches and managers can use the model to show the path to reliable Agile competence and find the “Agile” that’s right for them. Read more about the model at www.agilefluency.com .

Don Coleman - author, Beginning NFC

The internet of things is everywhere, but how do you interact with devices? This presentation will walk through using Apache Cordova to communicate with Arduino over Bluetooth. Don will demonstrate how to write cross platform Cordova applications to receive data from devices and control devices over Bluetooth. We will also cover the difference between Bluetooth Classic and Bluetooth Low Energy.

Connecting Arduino and Phones with Bluetooth and Cordova

Saul Mora - creator, MagicalRecord

Everyone loves to hate on Core Data. It’s a very powerful framework with many great features for keeping your applications in an Object Oriented world while persisting your application’s data. What if Core Data were easy to use? What if the boilerplate code was eliminated? What if the threading model was understandable? Check out my answers to these problems in this session! And, of course we’re going to cover MagicalRecord :)

David Richardson - Research Computing Systems, SIG
John Granieri - Research Computing Systems, SIG

All distributed systems are constrained by their ability to move data between components. We will talk about the engineering discipline required to achieve low latency and high throughput. Examples will be given from low latency C++ and high throughput python components used in SIG’s trading and data analysis stack. SIG is a proprietary trading firm headquartered in Philadelphia. No prior trading experience is assumed.

Darach Ennis - VP R&D at Ubiquiti Networks

Map Reduce begat Hadoop begat Big Data. NoSQL moved us away from the stricture of monolithic storage architectures to fit-for-purpose designs. But, Houston, we still have a problem – architects are still designing systems like they did in the ‘70s. Yet most systems are still designed for store-then-compute rather than to observe, orient, decide and act on in-flight data. Rather than just taking a spoonful of stream processing from large web companies with well intended open source engines, such as the Lambda Architecture, let’s look at the crazy architectures in high frequency trading such as Complex Event Processing (CEP). They got the techniques right, but the solution wrong – it didn’t scale. This talk isn’t about big, slow data; this talk isn’t about small, fast data. This talk takes a nuanced path through most of the rest which sits somewhere in between, with tradeoffs aplenty.

Saul Mora - creator, MagicalRecord

Mobile Apps are the new hotness. However, when it comes to building mobile apps, the new hotness can learn from some of the old skool design patterns made popular by the book Design Patterns by the Gang of Four. Many of the original design patterns introduced in this book are extremely useful in today’s network centric world. Classic Design Patterns can quickly solve problems using tried and proven techniques. However, technologies and other demands on our applications have changed, and new design patterns will emerge, many building on the old. Issues such as multi-core development, application security, peer to peer and app to app communications have introduced new problems for mobile application development, and we can gain insight for common, durable and robust solutions by looking for patterns.

Abhi Nemani - Former Technologist, Code for America
Governments spend hundreds of billions of dollars on technology, but they can adopt modern practices to reduce costs and improve services. And here’s the thing: they are.

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.

Jeff Hodges - Distributed Systems Engineer, Twitter

In the field, distributed systems are the new norm. This talk discusses tactics and strategy for productionizing distributed systems with a little bit about what the future will hold.

Eric Windisch - Docker Inc., Cloudscaling

There has been a lot of talk about Linux containers recently, and how they can help you beat “Dependency Hell”. Docker is one such technology that is using Linux containers to better deploy your applications. In the last year Docker has taken the DevOps world by storm. I’ll tell you what Docker is, how it works, and how to add it to your development toolbox.

Docker: The revolution will be containerized

Dana Bauer - Developer Relations Group, Rackspace

abstract coming soon

abstract coming soon

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.

Chris Merrick - Director of Engineering, RJMetrics

Generalists are Special

Software is easier to write today than ever before. With little understanding of what’s going on behind the scenes, a marketer can stream an API firehose into a distributed system to perform a data analysis in just a few lines of code. The proliferation of open source projects and sites like GitHub and Stack Overflow has created a broad toolset and reference library available to anyone with a web browser. At the same time, PaaS and IaaS providers have made one-click deployment and maintenance a reality.

This evolution has caused dramatic changes in marketing and operations departments, where more employees are writing and maintaining their own code, leading to the rise of new titles like “Growth Hacker” and “DevOps Engineer.” It has also fundamentally changed engineering departments, where specialists with deep domain expertise are no longer as mission-critical as they once were.

We will explore how RJMetrics has embraced this evolution by building our technology team around empowered software engineering generalists. These engineers are given broad exposure to enable context-aware decision making, and autonomy to execute those decisions without interference.

David Turanski - lead, Spring Data GemFire

2013 was a “pivotal” year for Spring! We saw the Spring family join Pivotal where – along with Cloud Foundry and our data driven technologies (the Pivotal HD Hadoop distribution, the GemFire data grid, and the RabbitMQ message broker). Today’s Spring embraces Java 8, Scala, Groovy, provides a best-in-class REST stack, supports the open web, mobile applications, big-data applications and batch workloads. Today’s Spring is easy to get started with, easy to learn, and embraces convention over configuration. Join Spring developer David Turanski as he takes you on a tour of today’s Spring, including the Spring.IO platform, Spring Boot, Websocket support, Spring HATEOAS, and more! This is a Spring you may not have seen yet.

Have You Seen Spring Lately

Tim Fox - creator, Vert.x

Vert.x is a lightweight, high performance, reactive application platform for the JVM that’s designed for modern mobile, web, and enterprise applications. In this talk you will learn about the design principles and motivation behind Vert.x and why we are heading for a reactive future.
You will also hear an overview including demonstrations of some of the key features of Vert.x including the distributed event bus which extends right into the browser, high availability, and the module system. Demonstrations will involve examples in Java, JavaScript, Scala, Groovy and Python.
You’ll also learn about how improved build tool and IDE integration simplify the process of developing applications with Vert.x – including short demonstrations of module auto-redeploy from the IDE and executable “fat jars”

Ellen Friedman - co-author, Mahout in Action

As machine learning emerges from research to find its place in practical applications, it’s useful to know some tips for how to build a simple but powerful recommendation engine. This talk explores how to choose effective data, how to use Apache Mahout to discover the “right kind” of co-occurrence and an innovative use of search technology for implementation. With Apache Solr to deploy the recommender, you save development time and have a dependable way to deliver rapid response recommendations in a production setting. We will also take a look at the current state of Apache Mahout, which has recently released a 0.9 version and discuss some of the best ways to get involved with this open source project.

Carl Quinn - co-host, Java Posse

The Netflix OSS Cloud stack is clearly a great set of components for building a cloud infrastructure and platform—if you are Netflix. But how does that architecture work for other businesses? Learn how at Riot we leveraged Netflix OSS Cloud tools and platform components to create a complete infrastructure for hosting our global game platform. Maybe it can work for you too.

This session will describe the libraries, services and tools from the Netflix OSS stack that we used, our adaptations and extensions, and how we put them together with a nifty Java library stack to form a cohesive platform.

On the Java development side, we adopted Dropwizard, added in some of the Netflix OSS libraries plus some of our own magic sauce to create a simple framework for quick development of robust, cloud-ready Java services.

We adopted Aminator’s pre-baked image model, but extended baking to use Chef to leverage our existing cookbook library. And instead of using Chef at launch for bootstrapping and configuration, we use Eureka for service discovery and an built an Archaius backend service for dynamic configuration.

We use Asgard as our general cloud portal, but have extended it with user authorization to fit our engineering environment. And, we use Edda and the Simian Army for security and conformance auditing, as well as routine cleanup tasks.

Sean McCullough - Engineer, Groupon

Groupon recently completed a year-long project to migrate its U.S. web traffic from a monolithic Ruby on Rails application to a new multi-application stack with substantial results.

Groupon’s entire U.S. web frontend had been a single Rails codebase from its inception in 2008. The frontend codebase quickly grew large, which made it difficult to maintain and challenging to ship new
features. As a solution to this gigantic monolith, we decided to re-architect the frontend by splitting it into small, independent and more manageable pieces. At the center of this project, we rebuilt each
major section of the website as an independent application. We also rebuilt the infrastructure to make all the independent apps work together. Interaction Tier (I-Tier) was the result.

Learn about how Groupon achieved this great architecture migration and the business results it is driving.

I-Tier: Breaking Up the Monolith

Brian Goetz - Java Language Architect, Oracle

When it was introduced nearly 18 years ago, Java was a combination of radicalism and conservatism; it made a bold gamble that garbage collection and JIT compilation would mature fast enough to be useful for mainstream programs, while eschewing then-trendy features such as operator overloading. Java succeeded beyond Sun’s wildest expectations, and now 10M developers program in Java. But the world hasn’t stayed still; the hardware, the developers, and the problems we want to solve today are not the same as they were 18 years ago. So, how has Java evolved to meet these challenges, and how will it continue to evolve in the future? This talk will look at where Java has been, where it is today, and where it may be going in the future.

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.

Cliff Moon - Founder & CTO, Boundary

Boundary was founded on a relatively simple idea: what if we were to use modern distributed data processing techniques to tackle a moribund industry; IT Monitoring? Further, we figured that if we could tackle the piece of the stack that outputs the most data, the network, then we could take on any data that our customers would care to throw at us. Along the way we built and threw away several databases, and changed from a database model to a streaming model, and are building something slightly different than all of that today. I will talk about our motivations along the way, how the shape and the overall volume of the data drove our architecture decisions. And, of course, I’ll talk about how we were able to derive value from a dataset that’s been deemed useless more times than I can count.

Aaron Mulder - CTO, Chariot Solutions

In the olden days, 3D in the browser meant something antiquated like VRML, Java3D, or other unpleasant formats and plugins. But many of today’s browsers can handle it natively via the HTML5 Canvas and
WebGL, based on the popular OpenGL standard. But wait, you say, the only way to program anything in the browser is via JavaScript! Sure, there are libraries like three.js to help, but JavaScript is so…
slow. Enter asm.js, a subset of the language specifically constructed for high performance. In this talk, we’ll look at the browser support, APIs, and JavaScript libraries for WebGL, and check out the changes needed to bump up performance with asm.js.

Look, Ma, No Plugins! Presentation

Tobi Knaup - co-founder, Mesosphere

Marathon is a framework built on Apache Mesos that provides a fault-tolerant and elastic scale-out architecture for any long-lived application like Ruby on Rails/node.js-based web applications or traditional J2EE servers like Tomcat. Marathon can run applications without modification, and supports running Docker containers as well. It provides a simple REST API for controlling the app lifecycle and allows scripting of custom deploy and release policies. Marathon automatically responds to failures and makes sure your apps keep running forever. It’s the init.d for your data center.

In this talk, we’ll cover how Marathon solves these common devops concerns:

Deploying many apps on large clusters Service discovery Scaling apps with demand Providing developers with a self-serve interface for launching apps Automatically handling software, machine, and rack failures Reducing infrastructure complexity

Jon Moore - Technical Fellow, Comcast Corporation

Many interesting “reference datasets” now fit in a single commodity server’s RAM, with more on the way as main memory sizes continue to grow. The open source Sirius library allows developers access to this data in native datastructures while managing the distributed systems heavy lifting of replication and persistence.

In this talk, I’ll describe what “reference data” means so that you can recognize this common use case in your own applications, highlighting problems that Sirius is a good fit for (and those that it isn’t). I’ll describe the overall architecture of a Sirius-based application—-the high-level concept of how it works. Finally, I’ll use a case study from Comcast as an example where Sirius is powering applications serving tens of millions of customers.

Gulrukh Ahanger - Exec Director, Applications Engineering, Comcast

Cloud computing is not a new paradigm and has been utilized by organization for a long time as private cloud computing. Outsourcing cloud computing has rapidly become more desirable due to higher availability and flexibility of compute resource that is cost effective. Organization are adopting hybrid model for running services, that is, utilizing private and public clouds for their work load. However, hybrid cloud adoption requires to rethink the deployment model; organizations split their data and applications between public and private cloud in unique ways and must solve multiple challenges. How do organization provide security between the realm of greater oversight and control in private cloud and the unknowns in the public cloud? Do the patterns for securing a service in a hybrid cloud deployment look different than used in traditional private cloud? This presentation will cover some of the challenges and patterns to make hybrid cloud secure and redundant.

Jan Machacek - CTO of Cake Solutions and Scala/FP enthusiast

Jan will show how the principles of reactive design apply to APIs. In particular, Jan will show how to serve & consume REST APIs using Scala and Spray. The talk will explain the components in Spray, how they build on each other to offer convenient abstractions, and how you can easily combine the different abstraction levels in your code. Jan will show how Spray makes the implementation of even complex APIs easy and understandable.

You do not need thorough understanding of Scala or the actor model (though knowledge of the Scala’s syntax will help). After the talk, you will understand the principles in Spray and how to apply them in your applications.

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

Building on the success of Reactive Extensions—first in Rx.NET and now in RxJava—we are taking Observers and Observables to the next level: by adding the capability of handling back-pressure between asynchronous execution stages we enable the distribution of stream processing across a cluster of potentially thousands of nodes. The project defines the common interfaces for interoperable stream implementations on the JVM and is the result of a collaboration between Twitter, Netflix, Pivotal, RedHat and Typesafe. In this presentation I introduce the guiding principles behind its design and show examples using the actor-based implementation in Akka.

James Roper - lead developer, Play Framework

Java 8 heralds a new era of reactive programming, with lambdas and promises taking the limelight as the bright new features of the language. To best take advantage of these features, Play Framework offers a ground up asynchronous full stack web framework, with a high velocity development environment, making it the most natural web framework to use with Java 8. This presentation will showcase the best that Java 8 has to offer in the world of reactive web development.

Matt Turck - Managing Director, FirstMark Capital

Our physical world is changing and all sorts of devices are appearing. What is the future of the internet of things and is your business prepared to participate?

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.

Filip Maj - Mobile Automator at SauceLabs, Apache Cordova committer

Are you testing your mobile apps? Why not? Appium (appium.io) allows for UI testing in browsers, hybrid and native apps. Appium is open source, built on top of WebDriver for test compatibility and supports iOS, Android, and FirefoxOS. Fil shows how you can use Appium to test your apps across a variety of platforms, simulators, and even real devices.

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

Larry Maccherone - creator, Luminize

Ironically, much of the Agile process is based on intuition. Folklore. Anecdotes. Tradition. Faith. Now, for the first time in Agile history, there is solid research backed by the hard numbers of
10,000 teams. And not surprisingly, that disturbs some existing foundations, rebuilding them with facts, evidence, and insights. This talk builds upon on­going research.

Linda Rising - Author, Design Patterns in Communications

I’ve wondered for some time whether much of Agile’s success was the result of the placebo effect, that is, good things happened because we believed they would. The placebo effect is a startling reminder of the power our minds have over our perceived reality. Now cognitive scientists tell us that this is only a small part of what our minds can do. Research has identified what I like to call “an agile mindset,” an attitude that equates failure and problems with opportunities for learning, a belief that we can all improve over time, that our abilities are not fixed but evolve with effort. What’s surprising about this research is the impact of an agile mindset on creativity and innovation, estimation, and collaboration in and out of the workplace. I’ll relate what’s known about this mindset and share some practical suggestions that can help all of us become even more agile.

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.

Ben Scheirman - Director of Technology, ChaiONE

Going from novice to expert requires years of practice. Yet "number of years” is still a poor indicator of how good a developer is. Good developers practice deliberately. This means going out of your way to experience new techniques, or repeating actions in order to build muscle memory. In this presentation, I’ll convey a list of tips & tricks that I have picked up in my continued journey as an iOS developer. I’ll cover quick tips that can save you time (like mastering the keyboard), software design practices such as identifying code smells, as well as refactoring & debugging techniques. No matter what your skill level, you’ll likely pick up something new you can use to be more effective as an iOS developer.

Gil Tene - co-founder and CTO, Azul Systems

Understanding application responsiveness and latency is critical not only for delivering good application behavior but also for maintaining profitability and containing risk. However, good characterization of bad data is useless. If measurements of response time present false or misleading latency information, even the best analysis can lead to wrong operational decisions and poor application experience. In this talk, Gil Tene (CTO, Azul Systems) will demonstrate and discusses some common pitfalls, false assumptions and problematic measurement techniques that lead to dramatically incorrect reporting results, and will explain how these false measurements naturally occur using the most common measurement methods and tools in use today. We will discuss the coordinated data omission problem, and ways to work around it, and will introduce and demonstrate how simple and recently open sourced tools can be used to improve and gain higher confidence in both latency measurement and reporting.

Kimberly Blessing - Director of UI Development, Think Brownstone

Organizations are increasingly looking at experience design as a means to creating better, more engaging customer experiences – but truly innovative organizations are also applying experience design principles to their internal processes and tools to create and sustain a more engaged workforce. In this session, learn what these principles are and find inspiration in examples of how other organizations are transforming themselves as a result of putting them in to practice.

Robin Ward - co-founder, Discourse

Browser Applications are all the rage these days. When we started Discourse, our next-generation open source forum software, we wanted a rich application that would last more than just a couple of years. To achieve this goal, we embraced the Ember.js framework and built a very heavy and powerful Javascript application. Along the way we learned quite a bit about the advantages of client side programming and enterprise design patterns. This talk is a walkthrough of the principles we learned and the challenges we faced along the way to client side nirvana.

Dean Wampler - co author, Programming Scala

Spark is an open-source computation platform for Big Data. Leaders in the Hadoop community, such as Cloudera, have embraced Spark as a replacement for MapReduce, the venerable standard for writing Hadoop jobs.

This talk explores why this change is needed. Spark provides two important benefits compared to MapReduce. First, its performance is significantly better than MapReduce. We’ll discuss why. Second, because Spark is implemented in Scala and rooted in the world of functional programming, it provides better, more composable primitives that make it easier for developers to create a wide variety of high-performance applications. We’ll discuss these primitives and look at some example applications.

Joel Spolsky - Founder & CEO, Stack Exchange

Abstract coming soon.

Camille Fournier - Head of Engineering, Rent the Runway

ZooKeeper is everywhere these days. It’s a core component of the Hadoop ecosystem. Your favorite startup probably uses it internally. But as every good skeptic knows, just because something is popular doesn’t mean you should use it. In this talk I will go over the core uses of ZooKeeper in the wild and why it is suited to these use cases. I will also talk about systems that don’t use ZooKeeper and why that can be the right decision. Finally I will discuss the common challenges of running ZooKeeper as a service and things to look out for when architecting a deployment.