eventer

Building a high performance financial exchange is tough, especially when you're flying in the face on conventional wisdom. In this case it is widely assumed that it's not possible to build a high-throughput near real-time system in Java. Over the past 4 years our experience of building LMAX, the world's first multi-asset financial exchange, we've learnt that much of what the industry believes about computer performance is based on folklore. Using evidence and experience from solving real world problems, this talk aims to dispel some these performance myths. We will cover a number of areas of software development including distributed systems, concurrency and parallelism, I/O, algorithms, garbage collection, and memory efficiency. We need to reintroduce the science into computer science and stop depending on mythology, technology is changing and mythology is not keeping up.

2011 might be considered the year of continuous deployment, and in this fast-paced world, development teams have begun asking a simple question: Are we delivering the right thing?As the pace of deployment moves from annually to quarterly to weekly and now daily, design is no longer something that happens once at the beginning of development, any more than testing and integration are things that happens at the end of development. And in this compressed delivery cycle, there are two areas of design need to be continually addressed: the problem space and the solution space. In the problem space, design takes on the role of sense-making, creative thinking, problem setting, and quick probes to check assumptions. When feedback from the problem space is continuous, having a few good design thinkers on an agile team is just as important as having a few good testers, because the biggest waste in software development is not building the thing wrong – it’s building the wrong thing. In the solution space, the technical design of the software must evolve in cycles to match the deployment cycles, so if the deployment is daily, design must be done daily as well. While software architecture and design may have been an occasional thing when releases were weeks and months apart, compressing the cycle requires a fundamental rethinking how we create and evolve the right architectures to support our systems over time. This talk will cover examples of continuous design in both the problem space and the solution space.

Watch in horror as Damian writes a Perl program to extract square roots using nothing but quantum mechanics, general relativity, and the very fabric of the space-time continuum. Along the way we'll also investigate: Wittgenstein's dark secret; the diminishing returns of physical computation; Roman philosophy; when Super Science Adventures go wrong; the greatest Lego kit of all time; the secret identity of Sith; carbon logic vs silicon logic; the giants of 1930's physics; elementary spin-half quanta under relativistic motion; CAT scans; Will Smith; bongos; drunken bets involving penguins; algorithmic consistency; God's dice and the problem of free will; intrinsic self-inconsistency; the many worlds outside Copenhagen; and the inventor of stage diving.

Complex software always has an architecture, even if it isn't intentional. Being agileisn't enough. It isn't prudent to just keep your code clean and hope that goodarchitecture will simply emerge. Especially when there is a lot of technicalrisk, interdependencies, and conflicting priorities. Good architecture requiresongoing attention and stewardship. This talk presents several techniques forincorporating architectural activities into complex agile projects and explainshow an agile architect's role differs from traditional software architects.

Today, many projects are increasingly focused on web based applications using web browsers as their primary user interface. How durable is this application architecture? Is the browser likely to continue to expand its primacy? Can we expect the basic structure of our web based applications to remain fairly stable for the foreseeable future or do we need to be preparing to make drastic changes? If the browser is a transitional technology, what might replace it? This talk will explore these and related issues and help you understand how application development is about to change.

Often a team sets out to design a new piece of software using a domain model. At first they are focused on strategically valuable new featuresand modeling sessions clarify the new approach the business wants to take. Then they get bogged down because the work necessarily involvesother systems. The newly designed part must be integrated with an external system and this leads to loss of clarity in the design. Or itmust be integrated with a legacy system, compromising the new model. In response, the team may try to redesign more of the legacy system, and the scope expands. There are many ways this may happen, but they lead to the same place. The narrow focus on strategic value is lost, and the fresh and clear new approach to the problem is muddied. This talk will describe a few of the ways that the strategic design patterns of DDD,in particular, Bounded Context, are used to avoid these problems and make timely delivery of new software of modest scope but high value that is integrated with existing systems without being mired in the outdated models of the past.

You\'ve heard about limiting WIP (Work-In-Progress) but how good are you at limiting red time? Red time is when you have compilation errors and/or failing tests. A growing group of practitioners have learned how to effectively reduce red time while test-driving and refactoring code. To understand how to limit red time, it helps to visualize it. In this talk, I will analyze live programming sessions using graphs that clearly visualize red time. You\'ll learn what programming processes help or hurt our ability to limit red time and you\'ll gain an appreciation for the visual cues that can help make you a better programmer and fellow member of the Limited Red Society.

WebSockets is a relatively new addition to W3C's HTTP specification that allows bidirectional, low-latency communication between browsers and web servers. This is particularly useful for applications that need to stream data to a browser. Most mainstream Java web servers/servlet containers don't yet support web sockets, and the few that do are either encumbered with APIs that make them hard to test or complicated to use.

JRuby is emerging as one of the most interesting language implementations on top of the JVM. Together with Groovy, Scala and Clojure, it is changing the way people are using and combining languages together with the Java platform.The Ruby language is beautiful, powerful and extremely malleable. By using Ruby on top of the the JVM it is possible to create the most combinations of languages, principles, paradigms and libraries.This presentation will introduce and explore JRuby, by first looking at its place in the Ruby ecosystem and then rapidly explore the manypossibilities a life on the JVM gives. JRuby can be used as an excellent platform for polyglot programming, and can take your project to the nextlevel. But it can also be lots of fun. Doesn't that sound like winning?

In this talk we'll explore the intersection of REST and DDD. Starting with a typical hypermedia workflow, we'll work through the mechanics of the Web and see how many common-sense distributed systems design principles are inverted as we design to increase surface area, scale, improve availability and compose services without breaking a sweat. We'll discuss how the Web transacts work strictly by side effects rather than explicit commands, and how it is optimised for repeatable, scalable queries. Finally we'll think through how aggregates work in a system where centralised control is impossible and federation is not only encouraged but normal.

In this talks, we\'ll talk about the key ideas of NOSQL databases, including motivating similarities and more importantly their different strengths and weaknesses. In more depth, we'll focus on the characteristics of graph stores for connected data and the kinds of problems for which they are best suited. To reinforce how useful graph stores are, we provide a rapid, code-focussed example using Neo4j covering the basics of graph stores, and the APIs for manipulating and traversing graphs. We\'ll then use this knowledge to explore the Doctor Who universe, using graph databases to infer useful knowledge from connected, semi-structured data. We conclude with a discussion of when different kinds of NOSQL stores are most appropriate the enterprise.

Riak Core is the distributed systems foundation for the Riak distributed database and the Riak Search full-text indexing system. Riak Core provides a proven architecture and key functionality required to quickly build scalable, distributed applications. This talk will cover the origins of Riak Core, the abstractions and functionality it provides, and some guidance on building distributed systems.

The plan for cashing in on a "million dollar idea" tends to start with step 1, an idea, and end with step 3, profit. The mysterious step 2 turns out to be the hard part, both because it is mysterious, and because it is much, much more complicated than one bullet point will allow. After having a doctor with a flashlight explain where ideas come from, we'll explore step 2. We'll start with presenter Mike Lee's €1000 an hour idea refinement service. Then we'll lay out the steps necessary to turn a refined idea into a product. We'll look at planning, implementing, and testing features. We'll explore team building, funding, and marketing. We'll take a close look at your customers, your platform, and your market. And we'll ask the all important questions of when and what we'll finally ship. With our virtual product hitting store shelves, we'll look at the real meaning of step 3. We'll talk about customer service, virality, and planned updates. Finally, we'll learn about the fear and consequences of success, and how to deal with them. Whether you have shipped an app, or are sitting on the next big thing, you won't want to miss this hilarious and irreverent nontechnical look at the hows and whys of making a living in technology.

Haskell is my first baby, born slightly before my son Michael, who is now at university. From somewhat academic beginnings as a remorselessly pure functional programming language, Haskell has evolved into a practical tool used for real applications and, amazingly, is still in a state of furious innovation.

If you want to program a parallel computer, it obviously makes sense to start with a computational paradigm in which parallelism is the default (ie functional programming), rather than one in which computation is based on sequential flow of control (the imperative paradigm). And yet... functional programmers have been singing this tune since the 1980s, but do not yet rule the world. In this talk I’ll say why I think parallelism is too complex a beast to be slain at one blow, and how we are going to be driven, willy-nilly, towards a world in which side effects are much more tightly controlled than now. I’ll give a whirlwind tour of a whole range of ways of writing parallel program in a functional paradigm (implicit parallelism, transactional memory, data parallelism, DSLs for GPUs, distributed processes, etc, etc), illustrating with examples from the rapidly moving Haskell community, and identifying some of the challenges we need to tackle.

We're all agile now, but some of us are still more productive than others. In this talk you'll gain an insight into one of the key characteristics of a successful continuous delivery SaaS business; in a single word: Feedback! With an interesting collection of stories from rocket engineering, electrical engineering, and software engineering, we're going to re-examine why agile development is now the norm. Take away lessons can be applied to everything you do including how you design software, how you release software, how you maintain software, and even how you get promoted.

Businesses rely on getting valuable new software into the hands of usersas fast as possible, while making sure that they keep their production environments stable. Continuous Delivery is a revolutionary and scalableagile methodology that enables any team, including teams within enterprise IT organizations, to achieve rapid, reliable releases throughbetter collaboration between developers, testers, DBAs and operations, and automation of the build, deploy, test and release process. We'll start by discussing the value of CD to the business, inspired by the lean startup movement. We'll then present the principles and practices involved in continuous delivery, including value stream mapping, the deployment pipeline, acceptance test driven development, zero-downtime releases, and incremental development. We'll cover how CD is enabled by an ecosystem including Devops, cloud computing, agile testing, and continuous deployment. Finally we'll talk about how continuous delivery can co-exist with ITIL and compliance in an enterprise environment.

Explore the world of CPU caches, bus bandwidth, and instruction sets, and how they execute your code: This session tells you how to take advantage of CPU and memory architecture, smart algorithms and the .NET Framework to make your apps blazingly fast. We'll also cover tips and tools to help you fine tune, and walk through the optimisation of some examples taken from the world of high frequency finance.

We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction - and Akka is here to change that. Akka is using the Actors together with Software Transactional Memory (STM) to create a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). Akka provides location and network transparency by abstracting away both these tangents of scalability by turning them into an operations and configuration task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication and partitioning. In this talk you will learn what Akka is and how it can be used to solve hard scalability problems. Akka is available at http://akka.io (under Apache 2 license).

Dart is a new programming language for creating structured web applications. It has an unsurprising and familiar syntax and it has been designed from ground up with performance and ease-of-use in mind. In this presentation, you will get the story behind Dart, an introduction to the language, and hopefully you will leave with good insights into how Dart will enable better web apps to be built.

With asynchrony the central theme of both C# 5 and Microsoft's upcoming .NET Framework, the question arises, what exactly is asynchrony? And why is it suddenly so important? This session will answer those questions in detail and then take a deep dive with practical examples demonstrating how to put this exciting new technology to work in C# 5. We'll cover the relationship between asynchrony and multithreading, imperative vs. functional asynchrony (aka Reactive Framework), the importance of hygiene in the thread pool, and most importantly... continuations! You'll see how C# 5's language support for asynchronous continuations makes it as easy as writing one line of code after the other - and why this is so important in simplifying the development of responsive and performant systems in today's interconnected world.

Shakespeare said "All the world is a stage" and with pervasive computing this has never been more true. As Mark Weiser predicted our computersand sensors are rapidly dissolving into the background of the world around us. But if this technology is truly pervasive then where doesthe User Interface go? This question shows why Augmented Reality is much more than just the latest novelty. It is part of a structuralchange in the way we use and interact with the network. This presentation will look at the sensors around us, the standards that aredeveloping and the challenges that lie ahead.

Celebrating the 10th anniversary of the agile manifesto in 2011 has been a fabulous achievement for a movement as much devoted to the welfare of technology workers as it is the delivery of real value to their employers and society in general. Today's agilists are at the cutting edge of a revolution in delivering value to society, but it seems they are standing on the shoulders of giants. This talk takes the long view back, reviewing a number of key lessons from the last 6 decades, from various case studies, a gratuitous number of which involve cool, high-tech space engineering and large scale teams that hung on a thread of agile and systems thinking in one way or another to succeed and innovate. Apart from lending some useful historical perspective, it also examines the extent to which a lean organisation is necessary to provide context to agile software developers, and how that impacts long term success. If your CEO doesn't get it, what hope do you have? And what happens to all the 'not very agile' tech-workers whose jobs are being heavily impacted by radical new* team structures?

The Lively Kernel showed that one could build a self-supporting development environment using only JavaScript and browser graphics. This kernel can be stored simply as a web page, and can come to life in any browser with no installation or plugins. Recent progress in the Lively Kernel platform enables drag-and-drop composition of active content from shared cloud-based repositories, empowering web developers and end-users alike. Attendees will learn from live examples of fun and useful web authoring and will leave with free and full access to all the tools shown.

Crankshaft is a new compilation infrastructure for V8, Google Chrome\'s JavaScript engine. By using aggressive optimizations, Crankshaft dramatically improves the performance of compute-intensive JavaScript applications -- often by more than a factor of two! In this presentation, you will get an insight into how we decide which functionsto optimize and how we gather type-feedback while running your code anduse that to turn the performance-critical parts of your JavaScript programs into efficient native code.

Building and operating any massive web-scale system is a hugeengineering challenge just to manage the number of computers involved.Delivering web-scale search is a huge scientific challenge as well the computing equivalent of building jumbo jets - given the sheernumbers and variety of documents and queries involved. Personalizationof web search adds the next level of complexity, where on every query weseek to match the best available documents to a user given everything wecan glean about their intent and context, and where no two users areidentical. You will learn about the axes of personalization, theessentials of measurement and experimentation, and the applications ofcontinuous implicit user feedback. Along the way, I will shareexperiences from the forefront of personalized web search relevance andranking.

Software developers struggle with complex problems for a living.Unfortunately, we don't have time to keep up with the enormous amount ofresearch in cognitive science that would help us be better thinkers.Linda Rising will share what she has been able to uncover. Some of it issurprising, even counterintuitive. Linda will report on the research andprovide some tips for better thinking.

There are over 250 languages that run on the Java Virtual Machine. Some run well, some run less well. Some are fast, some are slow. Some are useful and some... not so much. There are at least 20 different languages that are in quite extensive use, and many more cropping up every week. Java has not been a single language runtime for a long time, but there are still challenges for language implementors. With the release of Java 7, things have changed for the better. JSR 292 adds support for many interesting capabilties that language implementors are already using to great effect. This presentation will talk about the current state of the art of language implementation in the post Java 7 world - what has changed and what hasn't; and why you as a Java developer should care.

Mission critical applications such as telecommunications switches Erricson, global scale chat Facebook, high performance message buses Rabbit, and fault tolerant databases Riak must support massive fault tolerant concurrency and distribution. In our experience concurrency at scale requires a purpose designed virtual machine and its GC. In this talk we discuss our experience building the Erlang VMs with a particular focus scalability. We present challenges and solutions for concurrent VMs. We discuss some essential interactions between VM and language designed necessary to achieve scalability. We will also discuss our experience extending JVMs to support scalable concurrency.