Velocity Europe 2011 schedule

Tuesday 8th November 2011

  • Opening Remarks

    by Steve Souders and John Allspaw

    At 9:00am to 9:10am, Tuesday 8th November

    Coverage video

  • A Career in Web Operations

    by Theo Schlossnagle

    We'll take a whirlwind tour through the world of web operations and try to get a handle on both why it is a challenging occupation and how to do it better.

    At 9:10am to 9:40am, Tuesday 8th November

    Coverage video

  • Lightning Demo: Page Speed Online

    by Andrew Oates

    In this lightning demo we’ll cover the newest Page Speed Online features, including waterfall analysis and critical path highlighting. We’ll show you how to use Page Speed Online to analyze what’s in the critical path of the page load or the first paint, and which Page Speed suggestions should be implemented in order to reduce the time spent on that critical path.

    At 9:40am to 9:48am, Tuesday 8th November

    Coverage video

  • Lightning Demo: weinre - a Debugger for the Mobile Web

    by Patrick Mueller

    Today, web developers have a large number of diagnostic tools available to help debug their web applications, starting with browser-specific debuggers like FireFox’s FireBug and WebKit’s Web Inspector.

    Well, desktop web developers anyway. Most mobile platforms provide little in the way of diagnostic tooling for their browsers, leaving mobile web developers in a bit of a lurch.

    weinre (WEb INspector REmote) is an open source tool to help bridge the web debugging tool gap in mobile. It repurposes the Web Inspector user interface to allow you to interact with a live mobile web application, from the luxury of a desktop browser window.

    While not all of Web Inspector’s function is available in weinre, plenty of goodies are: the Elements panel to inspect and interact with the DOM, a Console to run arbitrary JavaScript code, inspection of LocalStorage and Web SQL storage, and timing and request/response data from XHRs.

    Come see a live demo of weinre at this session!

    At 9:48am to 9:55am, Tuesday 8th November

    Coverage video

  • If You Can Keep Your Site Standing Up When All About You Are Falling Down...

    by Robert Castley

    Sure, front-end performance focus is great. But when your site surges in popularity—a foregone conclusion for us all, right?—web scale preparation can avoid a ton of grief. Think you can’t test your site with hundreds of thousands of visitors from all over the world without weeks of sleepless nights coding open source tools? This demo from Robert Castley, Solution Engineer and Technologist at Keynote, shows you how to design, run, and analyze a complete Web load test in 5 minutes, with time to spare for tea and biscuits.

    At 9:55am to 10:00am, Tuesday 8th November

    Coverage video

  • What it means to deliver exceptional performance

    by Alois Reitbauer

    Everybody talks about fast websites, but how fast is exceptionally fast? What prevents us from being fast? How good are we in delivering exceptional performance? What do we have to do to become really fast? This fast-paced talk will answer all these questions in only five minutes. Which is the maximum time a user waits for a website to load.

    At 10:00am to 10:05am, Tuesday 8th November

  • The Future of Application Performance Management

    by Brian Doll

    Web applications are being shipped faster, deployed instantly to the cloud and are catering to the ever-growing needs of a technologically connected audience.

    How do you manage it all? How do you maintain high performance in your application, stay on top of your server performance and ensure your end users are getting the best service you can deliver? Find out with New Relic!

    At 10:05am to 10:10am, Tuesday 8th November

    Coverage video

  • The Relationship Between Faster Mobile Sites and Business KPIs: Case Studies from the Mobile Frontier

    by Joshua Bixby

    If you’ve been looking for compelling data that will help you make a case for investing in mobile performance, this session is a must-see.

    Mobile web users are demanding. 85% say they expect sites to download at least as quickly on their mobile devices as they do on their home computers. Almost half say that poor performance makes them less likely to return to the site. And one third say they would visit a competitor’s site next. Yet despite high user expectations, m-commerce sites continue to lag in performance, with the average site taking more than 9 seconds to load.

    Despite the technical constraints of delivering speedy mobile websites, some companies are emerging as leaders. But significant data is still hard to come by. To fill this gap, Joshua has dived into Strangeloop’s customer analytics to evaluate the relationship between performance improvements and business KPIs for m-commerce sites.

    In this session, Joshua will present brand-new data in detailed case studies that show how real-world companies have optimized the performance of their mobile sites, and as a result have experienced dramatic improvements in key performance indicators such as:

    Page views
    Cart size
    Attendees will walk away with a clear before-and-after picture that shows why speed is a critical factor in mobile success.

    At 10:35am to 11:05am, Tuesday 8th November

  • The Velocity of Dev Ops

    by Jon Jenkins

    The speed at which dev ops works is critical. It enables greater innovation and faster reaction in your business. Join Jon Jenkins as he talks about why it’s important to iterate fast, deploy fast, be wrong a lot, and learn from your mistakes.

    At 11:05am to 11:20am, Tuesday 8th November

    Coverage video

  • Betfair's Site Rebuild: Fast - We Promise

    by Tim Morrow

    Betfair recently launched a beta version of their Sports betting website and is in the process of rolling out the site to new customers. We would like to present our journey so far and our results:

    Faster page load times Improving our operational insight into the performance of our website Significantly increasing our rate of deployment through continuous delivery How it impacted our bottom line

    Our talk will explore the initiative in great detail. We will discuss:

    • Why we launched our Customer Commitment
    • The Betfair site architecture
    • Performance techniques applied including reducing the number of HTTP requests, reducing DNS lookups, minification, flushing the buffer early, eliminating iframes, using cookie-free domains for components, optimising CSS sprites
    • How we measure performance How we measure the key business metrics including page load times, conversion rates such as registration, bets placed and revenue per customer

    At 11:20am to 11:50am, Tuesday 8th November

    Coverage video

  • Monitoring Is Easy, Why Are We So Bad At It?

    by Theo Schlossnagle

    We’ll go over the fundamentals of monitoring and performance assessment. We’ll talk about what to monitoring, why to monitor it and how one should go about monitoring their systems, networks, applications and business.

    At 1:00pm to 1:45pm, Tuesday 8th November

    Coverage slide deck

  • Rethinking the Mobile Web Performance Experience

    by Jon Jenkins

    The complexity of website content (as measured by the HTTP Archive) continues to increase. Meanwhile, the number of mobile browsing devices is increasing at more than 25% each year. Due to their limited processing power, memory, storage and network bandwidth these devices pose new challenges in terms of web performance as sites become more complex. To date, the approach to solve these issues has been to create mobile versions of web sites with limited content and simplified layout. This talk will present a new way we are looking at the mobile browsing challenges at Amazon.com. We will present data about site latency among various classes of devices and usage of mobile versions of the site. Much of the presentation will focus on technical approaches to dramatically reduce web site latency for this class of users.

    At 1:00pm to 1:45pm, Tuesday 8th November

    Coverage slide deck

  • Know Your Engines: How to Make Your JavaScript Fast

    by David Mandelin

    The main part of the talk will explain how each major JavaScript language feature is compiled and run, how fast it is compared to other operations, and what “performance faults” can make it much slower than expected. For example, reading a property (x = o.p) is implemented by compiling a bit of code to get the property value very quickly for any object with the same properties. This means that if a given line of code reads a property always from objects that look the same, it is very fast; if it works on objects with different property sets, it is usually still fast; if it works on objects that don’t have that property, it will be very slow. I will avoid details that are interesting mainly to engine implementers in favor of giving concrete, intuitive models that developers can use to predict performance and understand performance problems.

    In the second, shorter part, I’ll talk about current and future work to make JavaScript go faster, and what it might mean for developers. One area is advanced research-derived optimizations, such as tracing (TraceMonkey), dynamic type profiling (Crankshaft), and type inference. These technologies have the potential to dramatically speed up programs, but they will probably work much better on programs where values usually have the same type, so developers should know something about what kinds of programs benefit. Another area is simpler, more practical additions, such as web worker threads, which enable multithreading in browser JavaScript, and typed arrays, which allow fast computation on arrays of integers, including pixel data. The main goal of this part of the talk is to give developers ideas about what new things may be possible in JavaScript in the near future.

    At 1:50pm to 2:35pm, Tuesday 8th November

  • Massively Sharded MySQL at Tumblr

    by Evan Elias

    When correctly architected, horizontal partitioning of data can lead to dramatically better fault tolerance and isolation, while significantly improving the manageability and flexibility of a web site. A well-sharded MySQL architecture can perform comparably to newer NoSQL solutions, while still offering the expressiveness of SQL and the time-tested robustness of InnoDB.

    The road to complete sharding of Tumblr’s primary data has been a long one, and I’ll discuss how, when, and why we transitioned from a single database, to several functionally-partitioned datasets, and finally to a massively horizontally-sharded architecture.

    Along the way, we’ve developed a set of tools that has made the sharding process significantly easier to execute and monitor. The bulk of this session will focus on the practical aspects of sharding, digging into the nitty-gritty of the tools we use to:

    • Transition from a single MySQL database to many without downtime
    • Automate the split of a large shard into several smaller ones extremely efficiently, without having to lock any rows or fail a single query, through clever use of MySQL replication
    • Determine the location of data in the application
    • Update the application’s database configuration across hundreds of web servers, without hitting problems from inconsistent state while the deploy is in progress
    • I’ll also cover some of the mistakes we’ve made, and the tools and tricks we used to gracefully back out of them, such as choosing the wrong shard sizes, and fixing uneven distribution of queries and data.

    The session will broadly appeal to engineers at rapidly-growing, MySQL-backed sites. The information presented is all drawn from first-hand experience, and mostly cannot be found in existing books or web sites. Some level of audience familiarity with MySQL is assumed, but previous experience with sharding, InnoDB internals, or MySQL replication is not required.

    At 1:50pm to 2:35pm, Tuesday 8th November

  • Measuring Web Performance

    by Stephen Thair

    How do you measure web page performance?

    We all talk a lot about how fast our web pages are but are we comparing apples with apples?

    There are at least 6 different ways to measure web page performance, and multiple metrics to gather such as initial render, “above the fold” time or onLoad event time.

    The goal of this talk is to put web performance measurement in perspective by identifying and classifying the different ways of measuring web performance.

    So what dimensions can we compare them on?

    1. Accuracy?
    2. What metrics do they collect?
    3. “Completeness” of measurement – e.g. can they measure 3rd party or CDN content?
    4. Ease of implementation / use?
    5. Scalability (e.g. are they suitable for “real-user monitoring” type solutions or are they more developer/single-user oriented?)
    6. Are they suitable for Mobile devices?
    7. Are they suitable for measuring web API’s?
    8. What’s the cost?
    9. Suitable for SME vs Enterprise?

    We will also talk about the “active monitoring versus real-user monitoring” debate… what are the pro’s & con’s of each approach and will one eventually supplant the other?

    At 2:40pm to 3:25pm, Tuesday 8th November

    Coverage slide deck

  • Quality of Service (QoS) for Web Applications

    by William Louth

    This session will demonstrate how many networking concepts and techniques related to Quality of Service (QoS) can be mapped and applied to web clients, web services, applications and runtimes providing an end-to-end resource management conceptual framework that offers resource protection (via call shaping & policing) as well as request prioritization based on contextual & dynamic classification. It puts forward the argument for applications to be viewed more like the underlying networking layer, adopting many traffic engineering and quality of service optimizations techniques. It presents a mapping guide from one domain to another and then shows how this has been implemented in a solution that offers a production QoS solution for applications developed in Java, Scala, JRuby/Ruby and Jython/Python as well as all other JVM languages and eventually other runtimes/platforms including Microsoft’s .NET/Azure.

    This session will also outline how QoS as applied to runtimes can be mapped to all execution points in the delivery of web based software services from client devices to backend services. It will demonstrate a working proof of concept using Apache web servers and app containers.

    At 2:40pm to 3:25pm, Tuesday 8th November

  • How DRY affects JavaScript performance - faster JavaScript execution for the lazy developer

    by Mathias Bynens

    Let’s unravel the grey area of improving actual JavaScript code itself and discover the truth and science of JavaScript performance patterns.

    While improving network performance of your scripts through file size and the script loading is critical, the run-time performance of your JavaScript code has the most direct effect of the visceral feel that your users experience.

    I created jsPerf.com, the JavaScript performance testing playground, to settle the scores of JavaScript performance recommendations. I’ve come up with a simple theorem — easily summarized. Basically, the biggest enemies of performance when it comes to JavaScript (in descending order) are:

    1. Reading/writing to the DOM
    2. Function calls
    3. Lookups (scope lookups, property lookups, array item lookups)

    Of course, there’s not much you can do in JavaScript without using any of these things. The idea is that if you can get rid of a DOM read by using a function call or a property lookup instead, you should do it. Similarly, if you can replace a function call with a scope lookup, go for it! It will result in DRY code with much better performance.

    I spend a lot of time reviewing other people’s JavaScript code for performance issues, and I think it’s safe to say this presentation covers about 70% to 80% of the improvements that I usually end up recommending. It’s a simple principle, and it’s easy to apply it once you understand it fully —there just needs to be someone to explain it all to you. I’m that guy!

    The basic gist of this idea fits in one slide, but I’d like to take the time to A) explain what exactly these slow things are (so even JavaScript beginners that don’t know what a scope lookup is can follow along); and B) show lots of practical, real-world examples of how applying this technique can result in better performance, regardless of whether you’re using JavaScript libraries or plain vanilla JavaScript. A is especially useful for people who are new to high-performance JavaScript, but B will be useful for more advanced JavaScript coders as well.

    I believe this technique is useful because it can be applied to all the JavaScript code you’ll ever write, and it’s guaranteed to have a positive impact on performance (among other advantages). It will be useful for both JavaScript beginners (because everything will be explained properly) and advanced scripters that want to focus on performance while coding JavaScript.

    At 3:55pm to 4:15pm, Tuesday 8th November

    Coverage slide deck

  • Our first DDoS attack

    by Cosimo Streppone

    Your website just went down. As you try to understand what has gone wrong, you quickly realize something is different this time. There’s no clear reason why your site should be down, but indeed it is.

    This talk is about the story of our team’s first unprepared fight against a DDoS attack.

    The idea (what I’d like to convey)

    I’d like to give a honest and detailed view of what happened when we were DDoS’ed. It was our first experience at this scale, and we were probably unprepared.

    I’d like this to be clear from the presentation, and give lots of details on how we searched our way around and figured out our next steps as the attack itself evolved.

    The outcome in the end was positive, and we were able to make some high-level changes to our infrastructure and architecture to (at least try to) better protect our systems in the future.

    Audience level

    intermediate to advanced
    most suited for operations engineers

    At 3:55pm to 4:40pm, Tuesday 8th November

    Coverage slide deck

  • Empirical Results from Page Speed and mod_pagespeed

    by Andrew Oates, jmarantz and Matthew Steele

    Page Speed Analysis tools provide performance metrics for web-sites, and mod_pagespeed and Page Speed Service automatically rewrite web sites by applying web performance “best practices”. But exactly what is the impact on web site latency and usability from implementing these transformations? We’ll share what we’ve learned from running Page Speed and mod_pagespeed in the field.

    What is the impact of specific web performance optimizations on metrics like page load time and time to first paint? What is the interaction between latency, page structure, and network-level decisions such as when to flush web pages so that browsers can start rendering? In this talk, we’ll present our latest findings and show developers how to apply these findings to their own web sites.

    We’ll conclude with a discussion of new features being added to Page Speed analysis & rewriting tools to translate these learnings into a faster web.

    At 4:20pm to 4:40pm, Tuesday 8th November

  • Be fast or stay behind - Building a Continuous Delivery Platform

    by Schlomo Schapiro and Ingmar Krusch

    Ten years of continuous growth leave many stretch marks on any website, like increasing maintenance overhead, lengthy and complex internal processes and lots of code and configuration that nobody knows about. A Windows-Linux migration in the past also does not help to achieve a clean platform.

    On the other hand, being a market leader does not leave any room for relaxation but requires us to stay ahead. We need to be faster than the competition and make sure that our own size and being part of a larger corporation does not slow us down.

    Continuous Delivery is not just a buzz word but the answer to many of our current problems. Today we envision our data center and the various IT departments as building blocks in a Continuous Delivery Platform (CDP) that strives to shorten the time it takes to convert an idea into productive code.

    This talk starts from a big picture of a typical web company and drills down into the technical and organizational challenges that stood in the way of creating a CDP. Our developers turning agile and doing everything through SCRUM was only the start of a series of profound changes that touched all IT departments and beyond.

    DevOps helped us a lot to explain to our management and colleagues what is going on and what we want. But only a brand-new deployment and configuration management brought the actual break-through to shared responsibility and teams developing operational thinking.

    An important learning was that engineers come together through solving common problems as a team. In our case we had to deal with two main concerns: Linux and Java.

    Linux being the choice operating environment we started to do things the Linux Way and package all our software, configuration files and even content into RPM packages, thus greatly simplifying the problem of deployment and system management. Since our developers build the RPM packages they also get much more involved in site operations and suddenly the whole DevOps idea actually works out for us.

    Java being the choice coding language (with a huge code base :-() and a lot of “Java thinking” lead us to write a bridge between Java and Linux: Our Nexus YUM plugin translates between a Java world that knows only Maven and a Linux world that likes to install packages via YUM. The automated build process in TeamCity creates RPM packages and puts them into the Nexus which serves the same RPM packages as a YUM repository to our servers. This simplifies the handover from development to operations and is a big performance boost for our delivery chain.

    These and other technical solutions come together with many organizational changes – e.g. giving developers more access in the data center – to create the foundation for our Continuous Delivery Platform and enable everyone to focus on working the software while relying on a reliable delivery tool chain below.

    Another important learning is the way how to ensure the management buy-in into what essentially started out as an internal grassroots movements. Previously closely guarded kingdoms are now open to common responsibility based on a trust relationship between development and operations.

    With even product owners seeing the business value of web operations, ImmobilienScout24 is now in a much better position to deliver business value as fast as possible to our web platform.

    We would like to share with you the details of our journey, the ideas that helped us along the way and the code that we wrote. This talk will be useful to both managers and engineers who want to embark on a similar path.

    At 4:45pm to 5:30pm, Tuesday 8th November

  • Fast Loading JavaScript

    by Aaron Peters

    What is the best way to get JS into the page?

    It’s been well know that scripts block. In older browser external scripts block next objects from being downloaded and in all browsers both external and inline scripts block DOM parsing and page rendering. Since 2008, per the recommendations of Yahoo! and Steve Souders’ book, the advice has been to combine external scripts and move the script to the bottom of the HTML in order to get optimal page performance. Then came the dynamic loading of scripts: appending a script to the DOM without blocking the UI thread. Script loaders like LABjs and Yepnope emerged, enabling web developers to load multiple script tags in a non-blocking way, while preserving execution order and even with the ability to couple external scripts with inline JS code. And the story continues. There is the defer attribute, the async attribute and async=false is coming soon.

    With so many ways to get JS code into the page, how do you, the web developer, decide which technique(s) to use to get optimal performance for your pages? As a starting point, you need a solid understanding of the various techniques and how they behave in the popular browsers under different conditions.

    My presentation will cover:

    • The various JavaScript loading techniques
    • Different test cases (example pages)
    • Browser differences (desktop only)
    • Good to know weird stuff (jquery + jquery UI + defer in IE<=9 == total failure)
    • I will present results of extensive, recent testing.


    • Solid understanding of various techniques
    • Browser differences
    • What to use in which use case (!)
    • Alternative titles for this talk:
    • How To Choose the best JavaScript Loading Technique(s)
    • Tips & Tricks for getting JavaScript into the page, fast.

    At 4:45pm to 5:30pm, Tuesday 8th November

Wednesday 9th November 2011

  • Designing for Disaster: How Teams Can Thrive in the Cloud

    by Jeffrey Veen

    A few months ago, Jeff sat on a couch in the Typekit offices, staring out the window, and wondering if everything their company had been working towards was about to slip through their fingers. How that story ends is interesting (spoiler alert: the company is still going strong), and Jeff will share lessons on how they got through it and why they were ready for it. But beyond that, he’ll look at how you, your team, your clients, or your company can cultivate a culture of making amazing things—not just on the next project, but on everything you work on for the rest of your career.

    At 9:10am to 9:40am, Wednesday 9th November

  • Lightning Demo: FITB: Network graphing done right

    by Laurie Denness

    Fed up with overly complex graphing tools? Want a simple but powerful way to monitor bandwidth throughout your infrastructure? FITB (fit-bee, or “fill in the blank”) is a tool designed to make polling every switch and router in your network easier, simpler to find, and with more detail than previously possible.

    At 9:40am to 9:48am, Wednesday 9th November

    Coverage video

  • Lightning Demo: Deep Dive Browser Diagnostics

    by Andreas Grabner

    Modern web applications require us to do more than just monitor network traffic. In a Web 2.0 world JavaScript execution and rendering times become increasingly important. Learn how you can use dynaTrace Ajax Edition to optimize your client side to ensure optimal performance. We will walk through a specific example to show how to find what makes your site slow and how to optimize it.

    At 9:48am to 9:55am, Wednesday 9th November

    Coverage video

  • Exhaustive End-User Monitoring: A Necessity in an Ever Complex Digital Environment

    by Arnaud Becart

    In an increasingly complex digital environment, end-user experience must be monitored exhaustively. We can’t focus only on external website performance. End-user experience must be addressed through active & passive technologies covering all B2C & B2B usages (data, voice, video), whatever the context (mobile, cloud, within or outside the firewall). ip-label will illustrate via real customer cases how they provide the largest portfolio of end-user monitoring solutions in the Application Performance Management industry.

    At 9:55am to 10:10am, Wednesday 9th November

    Coverage video

  • Anticipation: What Could Possibly Go Wrong?

    by John Allspaw

    We’re all aware that failures happen in every system, and that being prepared to respond to them is paramount. But bringing resilience to your site and your organization also means developing your anticipation muscles; to explicitly work out what fears you may have about your system’s limits and failure modes, and understand what you’ll do when those unfortunate events happen.

    This creative thinking about failure is what you use to guide your architecture, your development, your processes, your hiring, and hopefully: your business.

    Putting in place contingency plans for when things might go wrong means first having an engineer’s imagination for those possible failures and surprising outcomes.

    I’m going to talk about walking the fine line between immobilizing paranoia and a healthy but constant sense of unease in order to build your anticipation muscles.

    At 10:35am to 11:05am, Wednesday 9th November

    Coverage video

  • Full Stack Awareness

    by Artur Bergman

    Performance and operability doesn’t come from simply focusing on a single part of your application or infrastructure. They come from having a systemic view of what makes your stack work, what could bottleneck it, and what could bring it down. I’ll talk about this journey from kernel to continents.

    At 11:05am to 11:20am, Wednesday 9th November

    Coverage video

  • Taking on the Performance Challenge

    by Ivo Teel and Laurens van Hees

    Performance has always been something we at SPIL within Technology had thoughts about, but never really had full focus on. Within Development, the main focus has always been delivering features that the business requires from us; performance was never a mindset that we had during the creation of these features. As we have a global audience of 130 million unique visitors visiting our portals daily, we came to the conclusion that we needed to have more focus in the field of performance. We could get so much more out of our current users, by increasing their browsing experience not only from well connected broadband countries but also from countries that have more scattered performance.

    We’ll share with you what we had to do to get Performance on the map, challenges we faced, what we’ve been able to achieve so far and the lessons we’ve learned up until this point. Performance is now fully on our radar and we still have many things we can and will improve.

    At 11:20am to 11:50am, Wednesday 9th November

    Coverage video

  • Fast & Furious: Speed In The Opera Browser

    by Andreas Bovens

    From its early days, Opera has focused on providing its users with a snappy browsing experience on a wide range of hardware and OSes. In this talk, we’ll look at the latest versions of Opera for desktop, Opera Mobile and Opera Mini and explore how they make web pages super fast.

    At 1:00pm to 1:30pm, Wednesday 9th November

    Coverage slide deck

  • NoSQL performance in the real world

    by David Mytton

    NoSQL databases are now very popular, particularly for new projects.

    However, the same assumptions about deployment and scalability that have been understood from years of working with relational databases like MySQL don’t necessarily apply in the NoSQL world.

    Real world performance can really only be understood once the databases are running at scale but that’s too late to be discovering problems.

    This talk will examine the more popular NoSQL databases – MongoDB, Cassandra, CouchDB – to point out important considerations when deploying each of these technologies.

    It will include how to scale reads and writes, where each database faces bottlenecks (and how to resolve them) and how to deploy redundantly across clusters of machines.

    It will draw on real case study examples from my own and other company’s usage of each database.

    At 1:00pm to 1:45pm, Wednesday 9th November