by Erik Meijer
For the past decade, I have been on a quest to democratize developing data-intensive distributed applications. My secret weapon to slay the complexity dragon has been category theory and monads, but in particular the concept of duality. As it turns out, the data domain is an extremely rich source of all kinds of interesting dualities. These dualities are not just theoretical curiosities, but actually solve many practical problems and help to uncover deep similarities between concepts that at first look totally unrelated.In this talk I will illustrate several of the dualities I have encountered during my journey, and show how this resulted in a novel “A co-Relational Model of Data for Large Shared Data Banks”.
In a perfect world, every company would have a web “designer” that makes our web apps pretty. It’s not a perfect world. Web developers need to know some CSS!
We’ll start by quickly covering the basics of CSS. Then we’ll dive into the CSS3 features that are supported by recent versions of popular browsers. Finally, we’ll explore a way to improve the syntax of CSS.
Sass stands for “Syntactically Awesome Stylesheets”. It provides two new syntaxes for CSS. One is a superset of CSS3 and the other is a more concise version of that. Both are translated to standard CSS
by a Ruby application before a web site/application is deployed. The features Sass adds to CSS include variables, selector nesting, mixins and selector inheritance.
by Neal Ford
Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard. This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional languages as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you’ll leave with a much better understanding of both the syntax and semantics of functional languages.
by Ken Sipe
How does your team handle release weekend? Is it the whole weekend? Is everyone on call? Is there a way to reverse the decision mid-stream? How long would it take your company or team to push a single line code fix from dev into production? Way too many organizations handle the production release through manual and tedious labor following a lengthy to-do check list. Way too many organizations have no way to reproduce their production environment.
What if you could “test” your production release before production? One of the answers to the last mile of continuous delivery is GLU. GLU is an open source project for deployment automation. It was created by one of the co-founders of LinkedIn (Yan Pujante) for automation of LinkedIn’s deployment automation.
This session is a basic tutorial, walking through the configuration of a deployment out to multiple services. We will work through serial and parallel deployments, ensuring consistency and detecting problems. This session should be a sufficient introduction to walking through: 1) installation, 2) configuration, 3) multi-server deployments 4) manual updates and 5) automated updates.
In unreliable networks, with unreliable processors (also known as “The Cloud”) one must know all the ways their thing can fail; and just as importantly, how to recover. It is even better to have the ability to recover in an automated way. I’ll go over the common failure conditions in distributed systems, and then introduce you to Doozer, the highly-available, consistant data store that makes recovering from these problems easy.
Ratpack is a micro web framework for Groovy inspired by the Sinatra web framework for Ruby. Running Jetty and Groovy’s template engine at its core, Ratpack is very capable and extensible while also enabling you to write single file web apps. It fits the sweet spot for problems too small for Grails, yet too big to start from scratch. Ratpack takes routes, also known as URLMappings in Grails, and makes them the star of the show.
In this session, you’ll learn how to create Ratpack apps, manage the application lifecycle, authentication, and persistence, and how to interface with Grails applications. Frankie and Sammy would approve…
Unit testing is an important part of software development, and many frameworks exist to support it on iOS.
In this talk, I’ll give an overview of three unit testing frameworks (SenTestingKit, Google Toolbox for Mac, and GHUnit), two UI interaction frameworks (UISpec, UIAutomation), and a mocking framework (OCMock).
I’ll write tests for a simple application using all frameworks and evaluate them based on:
by Sean Cribbs
“NoSQL is awesome! I need to use it on my next project!” … [hours later] … “How the heck do I get my data out of this thing?!”
by Ian Robinson
Doctor Who is the world’s longest running science-fiction TV series. Battling daleks, cybermen and sontarans, and always accompanied by his trusted human companions, the last Timelord has saved earth from destruction more times than you’ve cursed Maven.
Neo4j is the world’s leading open source graph database. Designed to interrogate densely connected data with lightning speed, it lets you traverse millions of nodes in a fraction of the time it takes to run a multi-join SQL query.
When these two meet, the result is an entertaining introduction to the complex history of a complex hero, and a rapid survey of the elegant APIs of a delightfully simple graph database. With a data store packed full of geeky Doctor Who facts, we’ll have you answering questions of the Doctor Who universe like a die-hard fan.
We’ll start with an overview of jQuery UI and the widget factory. We’ll dive into how the widget factory works, how it provides a unified API across all jQuery UI widgets and how to leverage it to build your own widgets. We’ll also cover the jQuery UI CSS Framework and how to leverage existing themes with your own custom widgets, as well as how to build a new theme that will work with any widget that uses the CSS Framework.
by Charles Fry and Benjamin Manes
MapMaker is Google’s premier data structure for in-memory caching on the JVM. This presentation will cover lock amortization as a simpler alternative to techniques such as lock-free and elimination-based data structures. We’ll describe how amortized analysis can be used to avoid lock contention and how it is leveraged to support expiration, soft/weak reference collection, and bounded caches.
This talk will cover the theory and implementation of 6 unique functional data structures in Scala. We’ll start out with the concept of functional persistence and then dive right into actual data structures. Each data structure will be motivated and built up by the associated theory and ideas. All of these will be illustrated (with requisite colorful diagrams) and implemented with the necessary trappings to be a first-class Scala Collection. Finally, we’ll look at some of the real-world constraints imposed by hardware architecture and the JVM itself, touching on how these constraints affect data structure design in ways that the theory doesn’t show.
by Wesley Beary
Cloud computing scared the crap out of me – the quirks and nightmares of provisioning cloud computing, storage, … on AWS, Terremark, Rackspace, … – I mean, where do you even start?
Since I couldn’t find a good answer, I undertook the (probably insane) task of creating one. fog gives you a place to start by creating abstractions that work across many different providers, greatly reducing the barrier to entry (and the cost of switching later). The abstractions are built on top of solid wrappers for each api. So if the high level stuff doesn’t cut it you can dig in and get the job done. On top of that, mocks are available to simulate what clouds will do for development and testing (saving you time and money).
You’ll get a whirlwind tour of basic through advanced as we create the building blocks of a highly distributed (multi-cloud) system with some simple Ruby scripts that work nearly verbatim from provider to provider. Get your feet wet working with cloud resources or just make it easier on yourself as your usage gets more complex, either way fog makes it easy to get what you need from the cloud.
With the advent of the invokedynamic in Java 7, implementations of language runtimes on JVM will become much more performant and powerful. Invokedynamic in itself is however only the first stepping stone, the least amount of functionality exposed by the JVM sufficient to enable the new features. Language implementers still need a lot of plumbing for correct interoperability with Java objects: overloaded method resolution, property access, collections access, and so on. The JVM Dynamic Linker Framework provides these functions, a convention for specifying them as invokedynamic calls, and means to link the invocations. More importantly, it provides means for registration and discovery of the same functions for other languages, acting as a nexus that can transparently link call sites generated by one language implementation to code in another implementation. Thus, it allows a dynamic language runtime to handle not only POJOs, but also objects from any other dynamic language runtime that itself uses the framework.
by Nathan Marz
Storm makes it easy to write and scale complex realtime computations on a cluster of computers, doing for realtime processing what Hadoop did for batch processing. Storm guarantees that every message will be processed. And it’s fast — you can process millions of messages per second with a small cluster. Best of all, you can write Storm topologies using any programming language.
Storm has a wide range of use cases. The basic use case is “stream processing”: processing a stream of new data and updating databases in realtime. Unlike the standard approach of doing stream processing with queues and workers, Storm is fault-tolerant and scalable.
Another use case is “continuous computation”: streaming the results of a query to clients to visualize in realtime. An example is streaming trending topics on Twitter into browsers.
A third use case is “distributed RPC”: computing an intense query on the fly in parallel. With distributed RPC, a Storm topology is a distributed function that you can invoke like a normal function.
In this talk, I’ll release Storm as open-source. I’ll show how Storm’s simple programming model makes realtime computation easy, robust, and even fun.
by Susan Potter
Find out how to build decentralized distributed systems based on a Dynamo-esque philosophy using riak_core, which is used to abstract away some of the more complicated decentralized and distributed features of Riak KV, Riak Search and other applications. riak_core is an open source library written in Erlang that runs masterless distributed applications inside of it. Riak KV is a dynamo-inspired decentralized distributed key-value datastore that has received attention in the NoSQL world and is built
on top of riak_core.
In this talk I will demonstrate how to implement in applications built running in riak_core:
by Scott Chacon
Git is the version control system most of us use every day. However, there are some strangenesses to it. Raise your hand if you really understand the ‘reset’ command. When it comes down to it, this is one of the most interesting, fundamental and amazing commands that Git has, yet nearly everybody is afraid of it. This is just bad marketing. This talk will de-mystify the ‘reset’ command so that you are not only comfortable using it, but can do new and interesting things with it and in doing so will arrive at a better understanding of the entire Git system. We will explore the Three Trees of Git (HEAD, index, work tree) and all the cool and mind-bending fun you can have with them.
by Scott Davis
Apple sold 4.1 million Macs in Q4 of 2010 — an impressive number until you consider that they sold 7.3 million iPads, 9.1 million iPods, and 16.3 millions iPhones in the same timeframe. IDC reports that smartphones outsold desktop PCs across the board for the first time in history, and the trend is expected to continue in 2011.
The mobile web is here, and this talk aims to help you get your website up to speed. You can make some subtle tweaks to your existing website to make it more mobile friendly — accounting for the smaller viewport screen size, providing layouts for both portrait and landscape mode, and making your hyperlinks mobile-friendly. Or you can optimize it a lot by providing a dedicated website that leverages HTML5 local storage, application cache, and more.
As the mobile ecosystem continues to grow and fragment with devices from smartphones to tablets — running iOS, Android, WebOS, and everything else — having a coherent mobile web strategy can help smooth out the bumps and move you from a “one size fits all” mentality to a more adaptive, right-sized approach to web development.
Since Chloe works with any language, we’ll start off by showing how to integrate it with Java, Ruby, and Python apps. Next we’ll look at the various use cases of the realtime web and see how Chloe’s API will support you in all of them. We’ll then go into the performance and security characteristics of Chloe. Finally, we’ll talk about the operations side of Chloe. By the time you leave, you’ll know how to deploy, monitor, and most importantly, use Chloe like a pro.
Generic programming holds great promise – ultimate reuse, unprecedented flexibility, and never a need to reimplement an algorithm from scratch due to abstraction penalties.
Unfortunately, the shiny city on the hill is difficult to reach. C++’s generic power has effectively reached a plateau – anything but the simplest generic constructs quickly turn an exponential complexity/benefit elbow. C++11 fails to be a strong sequel in the generic programming arena, and many other languages don’t seem to “get” genericity properly at all. The D programming language is a definite exception from this trend.
D makes short work of the most formidable generic programming tasks achievable with C++, and makes virtually impossible tasks readily doable. It also reduces the relevance of “Modern C++ Design” to that of an introductory brochure (much to the dismay of that book’s author).
This talk has a simple structure. It will pose a few generic programming tasks that seem difficult or impossible with current language technology, and then will show solutions in D that solve said problems.
by Hilary Mason
This is not a prepared talk and will not include slides or other prepared materials. Rather, it is an open time for attendees to stop by and work on machine learning ideas. Hilary Mason will be available to offer advice and assistance. Bring a laptop if you wish to hack.
by Runar Oli
It has been said that Scala is an object-functional hybrid language, and Scalaz takes the “functional” side of Scala as far as it will go. A library of pure data structures, type classes, highly generalized functions, and concurrency abstractions, Scalaz provides the functional programmer with familiar tools, and inspires the imperative programmer to eschew all side-effects. It is simultaneously a testament to the power of Scala and an exposition of its limitations.
The Go programming language is fast like C and flexible like Python. Skynet takes advantage of Go’s powerful features to create a highly scalable mesh of service processes. Skynet services self-announce and self-configure when they start so that they’re immediately available to the rest of the mesh. Creating a Skynet service couldn’t be simpler: just use the built-in generator, insert your business logic and compile.
This presentation will demonstrate creating a service in Skynet, then deploying it to several servers. We will demonstrate Skynet’s self-healing capabilities and built-in monitoring, and discuss the features of Go that make Skynet possible. With Skynet your company worry less about uptime and spend more time on your customers.
The consistency model used by Riak is designed to continue operating well even when nodes in your Riak cluster are down or unreachable, a property which also makes it a good model for mobile data. To me, “down or unreachable” sounds a lot like “off or without-cell-phone-connectivity” – common states for a mobile device.
In this talk, I’ll present Riak Mobile, a component that can be embedded into your iOS or Android application to make it a full Riak replication-aware peer. Typical usages for Riak Mobile is as a mobile content distribution platform using one-way sync; or with two-way sync to also push updated data back to your Riak cluster when the network is “eventually” available.
In the talk, I’ll walk through how Riak Mobile works. The client-part of Riak Mobile does not require an Erlang VM. Rather, it comes as either a Java or an Objective-C component using local on-device storage, and thus integrates nicely into the native development environments. The server-part is an OTP application running with Riak. Riak Mobile uses a flow-based algorithm using Merkle trees and vector clocks optimized specifically for providing efficient incremental synchronization for slow, high-latency network conditions.
by Cyprien Noel
Imagine developing an application using the equivalent of source control for your data. Some STM (MVCC) enable this model for threads: a thread can take a snapshot of memory, run totally in isolation, and commit atomically.
Distributed STM are a recent development which enables this model for threads in different processes. In the same way a developer can check out a project on his local machine, an app. can replicate an object graph from a cloud, have local threads update it, and commit changes back to the cloud. The cloud can then broadcast changes to other clients’ replicas.
Developers can use this technology for scenarios like real-time collaboration, pub/sub, market quotes broadcasting, MMO game-state synchronization between players, or simply storing data in a cloud. The amount of code required on both client and server is an order of magnitude lower than models like REST, and performance can be much higher.
Many implementations are emerging, like the Fénix framework which is successfully running a large university campus portal, the JCell project, D²STM, Multiverse, or the EU-funded CloudTM initiative.
Our own implementation, xstm.org, started in the financial software industry for high performance price transfer and trading. It is open source (Apache 2), and has been integrated in several commercial projects over the past two years, each time adding new functionalities and tools.
We now have SDKs for Java, Android, GWT and .NET which can interoperate with each other for multi-platform apps, a high-performance store to make replicated objects persistent either locally (with offline sync to the server) or in a NoSQL store. Data can be exchanged over a socket, http (polling) or comet, and WebSocket.
We offer tools to deploy and debug a server in Amazon EC2, create secure connections and handle data versioning. We are also developing a cloud back-end, objectfabric.com, which developers will be able to use as a highly available auto-scaling service.
by John Hugg
Most developers are familiar with the special requirements of high volume OLTP applications such as airline reservation systems and capital market (“tick”) feeds – systems that process massive amounts of real-time data with “high 9s” availability and ACID-level consistency. Such extreme requirements demand highly specialized data infrastructures costing many millions of dollars.
Fueled by mobile computing, online gaming and interactive web applications, a new class of transactional systems is emerging. These systems have many characteristics of their traditional OLTP counterparts, including the need for guaranteed transactional consistency, but there are also important differences:
In this session, John Hugg will discuss real-world applications of high volume transaction processing. He’ll explore high- and low-frequency transaction profiles, as well as the need for real-time analytics. Importantly, John will also discuss how high volume transactional solutions like VoltDB can be integrated into existing data infrastructures.
by Nate Young
Parser combinators are a programming concept that can be used to parse and process a huge class of grammars. They are lightweight and nimble like a rhinoceros thrown from a plane at altitude is not.
This is mostly a technique talk. Parser combinators are not specific to a language, nor are they found in only a single, specific library. They fill a wide gap where DSLs come up short and full parser-generators like ANTLR or yacc are too heavy-weight.
Under the hood, parser combinators are left-recursive (one of the 2 best kinds of recursive), have infinite lookahead (which, disappointingly, can not be used for nefarious time continuum-related mischief) and, for fans of category theory, can be defined both in terms of an associative binary operator and an identity value (I understand if this doesn’t turn everyone’s crank).
I’ll explain all of the above and more, using sample code from diverse languages with that hope that I can impart a very practical knowledge to my listeners about what makes parser combinators tick and how they can be used to greatly expand the number of languages an application speaks.
We present a new statically typed JVM-targeted programming language developed by JetBrains and intended for industrial use.
The main design goals behind this project are to create a Java-compatible language, make it compile as fast as Java, make it safer than Java, i.e. statically check for common pitfalls such as null pointer dereference, make it more concise than Java by supporting local type-inference, first-class functions (closures), extension functions, mixins and first-class delegation, etc; and, keeping the useful level of expressiveness (see above), make it way simpler than the most mature competitor — Scala.
The compiler is being developed alongside with an IntelliJ IDEA integration, so the users will get IDE support as soon as they get the compiler (first public version is planned for the end of 2011).
by Bill Odom
Vim deserves its reputation as one of the most powerful tools in a developer’s toolbox — but it’s not exactly friendly and approachable. Even long-time users rarely employ more than a fraction of its capabilities, and new users are often left wondering why so many apparently-sane people won’t shut up about how awesome it is. The stark UI, the steep learning curve, the host of idiosyncrasies… mastering Vim is a challenge, and that’s putting it politely.
In this hands-on session, you’ll learn why it’s worth the effort.
We’ll quickly review the essentials of Vim, like modes, motions, operators, and commands, with an emphasis on why Vim works the way it instead of just how. With the fundamentals firmly established, we’ll work our way through real-world examples of using Vim to perform astounding feats that poor souls using lesser editors can only imagine. We’ll cover ways to integrate Vim with your environment, tailor it to your work, and generally bend it to your every whim. We’ll discuss important settings, advanced techniques, useful customizations, handy scripts, must-have plugins, crafty tips, and sneaky tricks.
In short, we’ll explore how to use Vim most effectively, so it lives up to the awesome reputation that you’ll soon be telling all your disbelieving friends about.
18th–20th September 2011