Sessions at QCon London 2012 on Thursday 8th March

In this talk I will be talking about use cases that motivate collection of large datasets, the infrastructure challenges that these create and what type of solutions and technologies are enabling organizations to surmount these challenges. These facets of big data will be highlighted through a case study around how these technologies enable Facebook to handle data sets at a multi petabyte scale. The talk will conclude with some current challenges that these technologies face and what future evolution paths that they may take.

Class loaders are at the core of the Java language. Java EE containers, OSGi, NetBeans modules, Tapestry 5, Grails and many others use class loaders heavily. Yet when something goes wrong, would you know how to solve it?

In this session we'll take a tour of the Java class loading mechanism, both from JVM and developer point of view. We will look at typical problems that you get with class loading and how to solve them. ClassNoDefError, IncompatibleClassChangeError, LinkageError and many others are symptoms of specific things going wrong that you can usually find and fix. For each problem we'll go through a hands on demo with a corresponding solution.

We'll also take a look at how and why classloaders leak and how can you remedy that.

Message-oriented Middleware (MOM) is a category of products that helps simplify the task of developing distributed applications over varying operating systems, network protocols, and hardware architectures. The Financial Services sector, especially the Capital Markets, have pushed messaging capabilities, scaling, and performance in the last 10 years with the advent of algorithm trading and the meteoric rise in trade volumes. Now other traditional messaging use cases, such as logistics, travel, web infrastructures, and command and control are looking to the current and next generation messaging systems to revolutionize application integration, distributed system development, and infrastructure consolidation. Big Data problems are pushing many traditional data driven organizations to look at messaging as a means to handle both increasing loads and the need for a more real-time analytics approach. In this talk, Todd will cover:

1) the key elements of messaging,
(2) how peer-to-peer messaging has revolutionized the Capital Markets latency race,
(3) how messaging systems are being implemented today and the technical challenges involved in designing for efficiency/scaling/resiliency,
(4) where messaging systems and use cases are headed in the next 5 years and why queuing is dead.

JavaScript was originally conceived to write little scripts that could add some interactivity to a web page. Today, it is used for increasingly large applications -- in the browser, but also on the server, e.g. using node.js. Cloud9 IDE is an Integrated Development Environment developed almost exclusively in JavaScript, both on the client and server-side, counting over 240,000 lines of JavaScript code. Managing a code base this large requires a solid code foundation as well as solid tools. During this talk I will describe the Cloud9 infrastructure as well as the libraries and tools we are developing to make it scale. Specifically, I will talk about the static analysis library we have developed to build good language support for JavaScript, including inline error and warning highlighting, the rename refactoring and, soon, code completion based on type inference

Frequently deploying to production puts bigger pressure than before on DevOps to make sure the good, qualified application is provisioned with no mistakes. This session will explore some common pitfalls with traditional Continuous-Integration that increase risk, introduce manual input and human error, and generally make DevOps cringe before hitting the “deploy” button.

We will then demonstrate automation techniques that overcome these issues using popular tools, like Maven, Gradle, your CI server, custom scripts and a Binary Repository. Whether you are building software for the cloud or in-house, this presentation will show you how to have completely automated production builds that release applications which are fully traceable, managed and ready to be provisioned with no fear!

A quick search on "Modelling" turns up more that 7,000 titles in the Computing & Internet Books section of Amazon. With that many authors willing to put pen to paper (or finger to keyboard), this talk will try to investigate why our industry still expends so much energy creating bad models. It will focus on the challenges to effective modelling that are thrown up by both Agile development teams and the Finance business sector, based on experiences over the last 4 years at LMAX, building the world's first retail financial trading exchange.

We all want to use HTML5 and the hot new features being implemented in our favorite browsers right away, but how can we use these awesome new capabilities while ensuring older browsers (like our friends IE6, 7 and 8) still render pages and features as expected?

Pollyfills are here to help. Polyfills are JavaScript shims that replicate the standard API found in native features of new browsers for those without such features and in this talk you'll learn how to both use specially written JavaScript to emulate HTML5 features and even pick up pro-tips about writing your own polyfills along the way

Garbage Collection is an integral part of application behavior on Java platforms, yet it is often misunderstood. As such, it is important for Java developers to understand the actions you can take in selecting and tuning collector mechanisms, as well as in your application architecture choices.

In this presentation, Gil Tene (CTO, Azul Systems) reviews and classifies the various garbage collectors and collection techniques available in JVMs today. Following a quick overview of common garbage collection techniques including generational, parallel, stop-the-world, incremental, concurrent and mostly-concurrent algorithms, he defines terms and metrics common to all collectors. He classifies each major JVM collector's mechanisms and characteristics and discuss the tradeoffs involved in balancing requirements for responsiveness, throughput, space, and available memory across varying scale levels. Gil concludes with some pitfalls, common misconceptions, and "myths" around garbage collection behavior, as well as examples of how some good choices can result in impressive application behaviour

Hadoop provides a consistent model and infrastructure for seamlessly scaling analytics and data processing from small to very large sizes. This talk will provide an overview of Hadoop, its processing model, and its associated ecosystem and tools. We will examine the motivation and implementation of several real-world uses of Hadoop to analyze, process, and serve data for mission critical systems.

In the challenge to reach the lowest possible latencies, as we push the boundaries of transaction processing, the good old fashioned lock just imposes too much contention on our algorithms. This contention results in unpredictable latencies when we context switch into the kernel, and in addition limits throughput as Little’s law kicks in. Lock-free and non-blocking algorithms can come to the rescue by side stepping the issues of locks, and when done well can even avoid contention all together. However, lock-free techniques are not for the faint hearted. Programming with locks is hard. Programming using lock-free techniques is often considered the realm occupied only by technical wizards. This session aims to take some of the fear out of non-locking techniques. Make no mistake this is not a subject for beginners but if you are brave and enjoy understanding how memory and processors really work then this session could open your eyes with what is possible if you are willing dedicate the time and effort in this amazing subject area. The attendees will learn the basics of how modern Intel x86-64 processors work and the memory model they implement that forms the foundations for lock-free programming. Imperial evidence will be presented to illustrate the raw throughput and potential latencies that can be achieved when using these techniques.

Following a brief review of the CAP theorem in this talk we take a look at our direct experience of developing high performance applications using multiple NoSQL solutions for mass audience participation. We share the experience of our 18-month journey through multiple approaches to find the optimal combination of speed, reliability and consistency. The talk will frequently feature real-world battle stories including our experience with node failures and sibling explosions in a distributed environment.

Horia Dragomir will show you how to use the new features in HTML5 to create mobile games and the hoops you have to jump through to build a sleek and responsive user interface while trying to avoid most of the headaches that come with the job when you are always an edge case.