ACCU 2014 schedule

Tuesday 8th April 2014

  • Accelerated Agile

    by Dan North

    Great software professionals build better software faster. Agile methods, continuous delivery and software craftsmanship helped speed up delivery from years to months or even weeks, but then what?

    Some teams are able to deliver software at a speed of change like you have never seen before, delivering quality software in days or even hours, again and again. So what is keeping the rest of us from doing so? Now is the time to go from months to minutes, to rethink the way we organize and improve our software development and delivery process.

    Accelerated Agile is for people who believe it can be done. People who feel themselves limited by current Agile, CD and Craftsmanship thinking. People who want to go back to basics and uncover new, simpler ways to deliver great software. Are you a seasoned agile developer who is frustrated at how slow your "hyper-performing" process feels? Are you suffering with an unwieldy feature backlog, the pantomime of estimation, the card wall where cards go to die, the efforts to automate where it obviously isn’t adding anything? Are you fed up with the artificial commitment of sprints and the unwelcome surprises that still seem to derail your projects?

    Accelerated Agile brings agile principles into the 21st century. You will learn new techniques that both enhance and replace existing agile practices, some of which are counter-intuitive and many which are completely counter to current "agile" doctrine. Using a mixture of discussion, instruction and exploration you will start to think differently about design, architecture, development and testing, operations, automation and team dynamics, as well as working with legacy systems and integrating with third parties.

    What you will learn

    How to challenge the received wisdom of established Agile methods
    How to design and architect for rapid and sustainable delivery
    Why understanding risk and embracing uncertainty are at the heart of faster delivery
    How to manage build, release and operations
    How systems thinking can help you plan effectively and estimate accurately
    How to identify and reduce gaps in your testing strategy
    How to engage with legacy systems and integrating with third parties
    How to manage different levels of skill and experience within a team

    At 10:00am to 5:00pm, Tuesday 8th April

  • Architecture Engineering

    by Tom Gilb

    The use of a quantified Planning Language to articulate all quality and other performance variable attributes of all designs, architecture ideas, and strategies as a basis for Architecture Decisions and Quantified Agile Project Management (Evo)

    We will teach the following practical tools:

    1. The discipline of estimating the impact of any type of 'design idea' on any quantified system requirement level (as defined by a Scale of measure, and a Goal or Tolerable level of requirement)

    2. The corresponding discipline of estimating the design costs in several dimensions such as capital expenditure, calendar time, and human resources

    3. The use of the Impact Estimation Table discipline, for articulating the quality of estimates: +- uncertainty, % of Goal or Budget, Source, Evidence, Credibilty, Safety Factor

    4. Process and Specification standards: Procedures, Rules, Templates, Principles, for Architecture Engineering. Derived from the Competitive Engineering book (digital copy supplied free).

    5. Case studies of use of the Architecture Engineering method

    6. Application of Dynamic Design Prioritization

    7. Project Management consequences of this basis for articulating the Architecture.

    At 10:00am to 5:00pm, Tuesday 8th April

  • Coderetreat!

    by Mike Long

    Coderetreat is a day-long, intensive practice event, focusing on the fundamentals of software development and design. By providing developers the opportunity to take part in focused practice, away from the pressures of 'getting things done', the coderetreat format has proven itself to be a highly effective means of skill improvement. Practicing the basic principles of modular and object-oriented design, developers can improve their ability to write code that minimizes the cost of change over time.

    At 10:00am to 5:00pm, Tuesday 8th April

  • Lambdas and Streams in Java 8

    by Angelika Langer and Klaus Kreft

    In this workshop we explore new language features in Java 8 (i.e., lambda expressions, method / constructor references, static and default interface methods) and the overhauled collection framework in JDK 8 (i.e., streams, collectors and functional interfaces). Attendants are encouraged to bring their notebooks. We will not only explore the novelties in theory, but intend to provide enough information to allow for hands-on experiments with lambdas, streams and consorts.

    Audience: Java developers interested in the language extensions and collecton enhancements in Java 8.

    Level: intermediate

    Prerequisite: working knowledge of Java

    At 10:00am to 5:00pm, Tuesday 8th April

    Coverage slide deck

  • Mock that Legacy C - Hands on

    by James Grenning

    You have test-driven in other languages but need to sharpen your skills for C or C++. In this session we'll test-drive code using CppUTest and CppUMock. You'll also take the legacy C challenge and use all the tools of the trade to get this code, never meant to be unit tested, into CppUTest. To effectively mock and fake in C and C++ you need to know your tools and use them in creative ways. Each stage of compilation must be mastered to tame the legacy C beast.

    This tutorial is not just a show and tell. Bring your laptop with wifi access and a web browser. You will write code. This tutorial is not designed for the TDD beginner, but if you are one, we'll pair you with someone that has been there before.

    At 10:00am to 5:00pm, Tuesday 8th April

  • Switching to C++11 and C++14 in one day

    by Nicolai Josuttis

    C++11 is standardized and C++14 is around the corner. This raises the question for existing C++ projects and their programmers whether and when to switch to the new language and its library. This tutorial tries to answer that question in one day. It gives a brief overview about the new key features of the new C++ (including the key elements auto, range-based-for-loops, initializations, variadic templates, lambdas, move semantics, and new language features for polymorphism) and introduces the key elements of the new C++ standard library. A couple of example programs demonstrates the typical application of the new style. As a result the attendee will have a good understanding about the benefits of the new C++ standard.

    At 10:00am to 5:00pm, Tuesday 8th April

Wednesday 9th April 2014

Thursday 10th April 2014

  • Why Agile doesn't scale (and what you can do about it)

    by Dan North

    Agile doesn't scale. There, I said it. Actually people have been telling me that for over ten years, and I've just refused to believe them, but they were right. Does that mean you can't deliver large-scale programmes using agile methods? Not at all. But to scale you need something else, something substantively different, something the Agile Manifesto and the existing team-scale agile methods don't even have an opinion about.

    I have seen a handful of successful large-scale deliveries across multiple agile teams, multiple locations and multiple programmes start to look uncomfortably like those of traditional programmes, and involve phrases like delivery assurance, governance and portfolio management. They just approach them differently.

    What made them work? The challenge is getting large numbers of people to think in the same direction. Shared guiding principles, a clear vision and a common understanding enable what I call contextual consistency. I believe this one lever is the single greatest enabler of technology delivery at scale, and is at the heart of the thing we call empowerment. In this talk I will explain why.

    At 9:30am to 10:30am, Thursday 10th April

  • Ligthning Talk: Smile, you're on camera

    by Dirk Haun

    Take the title of this camera literally - because I'm wearing a camera! No, it's not Google Glass. It's a much simpler camera that only takes a photo every 30 seconds.

    But why would I do that? I'm experimenting with "lifelogging".

    At 6:20pm to 6:25pm, Thursday 10th April

    In Bristol Marriott Hotel City Centre

    Coverage slide deck

Friday 11th April 2014

  • Biological Realms in Computer Science

    by Didier Verna

    In biology, evolution is usually seen as a tinkering process, different from what an engineer does when he plans the development of his systems. Recently, studies have shown that even in biology, there is a part of good engineering. As computer scientists, we have much more difficulty to admit that there is also a great deal of tinkering in what we do, and that our software systems behave more and more like biological realms every day.

    This keynote will take you to a journey through the bonds between biology and computer science. Starting with an epistemological and historical view, we will see how these bonds developed over the years, but we will also ask ourselves whether these bonds were intentionally created, or whether they already existed, before we even found them. We will also meet the Engineer and the Tinkerer, and see that they are not necessarily different persons. Finally, through such notions as Determinism, Predictability and Control, we will envision and explain a possible future for our software systems seen as living organisms; a future that's in fact already here, but that we are reluctant to accept.

    At 9:30am to 10:30am, Friday 11th April

    Coverage slide deck

Saturday 12th April 2014

  • Executors for C++

    by Detlef Vollmann

    Executors (or schedulers) will be a base building block in C++ for asynchronous and parallel work. Executors for asynchronisity are somehow similar to allocators for containers: They are a very important implementation aspect, but for most people they are hidden behind the scene.

    Many programmers don't care more about executors as they care about allocators: they just take the default implementation and are generally happy with it.

    Developers concerned with performance however want to have a closer look to executors, to understand what different design dimensions exist for executors and what implications they have on performance and programming model.

    This talk will not only present the current proposal for addition of executors to C++, but also all the background and consequences of executors for the different (proposed and existing) C++ mechanisms for concurrency, parallelism and asynchronisity.

    Intended audience:
    This talk is for programmers and designers who are interested in some background for an asynchronous C++ world.

    At 9:30am to 11:00am, Saturday 12th April

  • Extended XP Game

    by allan kelly

    Back in the days when Extreme Programming was new, and agile referred to acrobatics, someone created a game to explain XP to teams. Allan Kelly too played this game to learn, and then he played it to teach others and he did it again and again. And in doing so he added bits, found new lessons and improved the game. It is now a standard part of his agile introduction tutorials.

    90 minutes is just enough time to play the game and learn some lessons. This will be a slide-free, hands-on, high-energy, fun session in which you will learn a lot, even if you know that agile extreme programming isn't about jumping out of a barrel rolling airplane with a keyboard and a parachute at 30,000 feet.

    At 9:30am to 11:00am, Saturday 12th April

  • Machine Learning for Fun and Profit

    by Burkhard Kloss

    Machine learning is a popular field at the moment, and there are a plethora of techniques and a bewildering array of free tools and libraries that are becoming available.

    A lot of the literature is highly academic and theoretical. I propose to give an brief overview of some of the field, then narrow the focus on one or two tools and a handful of techniques and go through some practical examples. Give my background, some of those are likely to be financial, but I'll make sure to include some more conventionally amusing ones.

    At 9:30am to 11:00am, Saturday 12th April

    Coverage slide deck

  • The Evolution of Good Code

    by Arjan van Leeuwen

    What do we think of as good code, and how has our perception of good code changed from the early days of programming to the exciting times we live in now? Did the emergence of new programming languages, the rise of functional programming and the need for parallelism change our general opinion? What do we mean when we say code is "modern", or "in line with current best practices"? Are we building on a body of knowledge, or just re-inventing the wheel every 10 years?

    In this talk we will do a fair bit of digging into the short history of programming, look at the available literature and different coding styles promoted throughout the ages, and have some fun looking at the good, the bad and the ugly historical code that's out there. The session will be interactive, with room for discussion about our personal preferences and the reasoning behind various bits of advice that history has left us with. And after talking a lot about the past, we will also try to see what all those changes mean for our code in the future, and what trends we can see developing right now.

    At 9:30am to 11:00am, Saturday 12th April

    Coverage slide deck

  • What Programmers Want

    by Gail Ollis

    If you have ever asked yourself "Why did they do THAT!?" when wrestling with a fellow programmer's work, you are the intended audience for this session.

    I am engaged in research to try to answer this question, or at least ask better versions of it. Although it often goes no further than an expression of frustration, it is actually a question that deserves closer scrutiny because it is important to productivity and morale. In order to address it and help programmers avoid the pitfalls that provoke an exclamation of "Why did they do THAT!?" I first need to be clear about what "THAT!" is. I have interviewed software developers with a total of more than 400 years of industry experience between them to find out. In this interactive session I will share the common themes that have emerged: what experienced developers say about the decisions made by their peers and how these can make the job harder or easier. Participants also told me that they enjoyed the method I used to help them to reflect on their pro- gramming experience, so I will give you the chance to try it out for yourself.

    At 9:30am to 11:00am, Saturday 12th April

    Coverage slide deck

  • Complementary Visions: Integrating C++ and Python with Boost.Python

    by Austin Bingham

    Python and C++ are both popular languages that each bring a lot to the table. The languages also complement one another well: Python is high-level, dynamic, and easy to use while C++ is at-the-metal, static, and (in)famously tricky. There are times when there are real advantages to combining these disparate natures, and Python's C API provides a strong interface for doing just that. Boost.Python is a C++ library that builds upon and improves Python's C API to give users a simpler, more intuitive, and safer means to integrate Python and C++.

    In this talk we'll look at how to use Boost.Python to effectively bridge the Python/C++ boundary. We'll start by briefly looking at the fundamentals of the Python C API since that defines the 'ground rules'; this includes things like reference counting, the basic object model, and so forth. We'll then take a look at the Boost.Python API and show how it provides the same functionality as the underlying C API, but does so in a way that doesn't obscure the real semantics of the Python language.

    Specific topics in this talk will include:
    Exposing classes across the language boundary
    Proper exception handling techniques
    Module initialization
    Packaging and code structure
    Debugging and profiling
    Negotiating the very different type system
    Compilation and linking requirements

    We'll look at using Boost.Python for both extending Python (using C++ code in Python) and embedding it (using Python code from C++.) Audience members will learn enough to do fairly sophisticated Python/C++ integration right away, they'll see how easy it is to use Python rather than 'greenspunning' their own language, and they'll get the orientation they need in order to learn the rest of what there is to know.

    At 11:30am to 1:00pm, Saturday 12th April

  • Crafting more effective technical Presentations

    by Dirk Haun

    The typical technical presentation in 2014 still consists of slides full of bullet points, completely ignoring evidence showing that this form of presenting is not very effective in helping your audience understand and remember your content.

    In this session, you will learn how to create more visual and engaging presentations. We will cover the research that explains why these presentations do in fact work and refute the common misconception that such an approach is really only good for high-level talks, such as keynotes.

    Topics covered include the preparation (focus on your audience's needs and expectations), some brief tips on slide design (avoiding bullet point overload), and general tips on the act of presenting (connecting and interacting with your audience).

    This session has some interactive elements. Please bring pen and paper.

    At 11:30am to 1:00pm, Saturday 12th April

    Coverage photo link

  • Looking for Smoking Guns in a Haystack - using a graph database for JVM heap analysis

    by Nat Pryce and James Richardson

    Late in the development of a major new feature for one of the most widely used consumer products in the UK we encountered potentially show-stopping memory fragmentation issues. Our platform uses a proprietary embedded JVM that has limited diagnostic tooling. We therefore had to build our own tools under intense time pressure. We used an open source graph database (Neo4J) and its query language to rapidly build an ad-hoc analysis tool, and successfully used it to track down and eliminate the problematic code from our product. We will discuss some of the challenges we faced using Neo4J for interactive analysis of quite large data imports (80K nodes, 150k relationships) and how we overcame them. We will then demonstrate (with live-coding) some queries to show the audience surprising aspects of our code, platform and Oracle's Java compiler.

    Many aspects of software can be modelled as graphs. Our experience shows that graph databases are a powerful foundation upon which to build software development tools. Thanks to increasing commoditization, we believe graph databases hold a lot of promise for non-mainstream programming platforms that are usually underserved by tool vendors.

    At 11:30am to 1:00pm, Saturday 12th April

  • Polymorphic Allocators for Fundamental Libraries

    by Alisdair Meredith

    One of the key resources in any C++ program is memory, as every object must, if nothing else, occupy some memory itself. Unsurprisingly, this has lead to many attempt to find "a better memory allocator", often with competing priorities. Do you want a faster allocator? Thread-specific allocation? Or more "secure"? Do you want to better track leaks and report errors? Or simply monitor usage patterns?

    With polymorphic allocators, you can pick the most appropriate type of allocator for your specific problem, on a per-object basis rather than per-whole-application. There is over a decade of experience with this allocator model at Bloomberg, and it is now planned for standardization as part of the forthcoming Library Fundamentals TS, building on the foundations for custom allocators laid down in C++11.

    This session will explore the motivation for using custom allocators, highlighting the value of being able to specify per-object. It will then walk through the facilities and some of the proposed new allocators for the fundamentals TS, and discuss some of the implications of programming with this new model.

    At 11:30am to 1:00pm, Saturday 12th April

  • The continuing future of C++ concurrency

    by Anthony Williams

    An overview at the additions to the Standard C++ concurrency libraries proposed for the C++ concurrency TS and C++17, including: continuations, executors, and parallel algorithms, as well as std::shared_mutex from C++14

    At 11:30am to 1:00pm, Saturday 12th April

  • Everything You Ever Wanted To Know About Move Semantics (and then some)

    by Howard Hinnant

    Get the lowdown on move semantics from the person who put move semantics into C++11. Learn what the best practices are and what popular practices are not best. Learn about the interaction of move semantics with noexcept, and exception safety. Learn when to default and when to delete special members, and even more importantly, when not to.

    At 4:30pm to 5:30pm, Saturday 12th April

    Coverage slide deck