ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation


Sponsored by:
Logo Learning connexions
Mosaic Financial Markets
Organized by:
Conference Chair:
  Jon Jagger
Conference Committee:
  Astrid Byro
  Francis Glassborow
  Olve Maudal
  Roger Orr
  Ewan Milne
Event Manager:
Archer Yates Associates Ltd
Threshers Yard, West Street
Kingham, Oxon. OX7 6YF
Phone: +44 (0) 1608 659900
Fax: +44 (0) 1608 659911
Email: julie at
Conference 2014

Abusing CSharp 5

presentation: 90 minutes
Horrible but entertaining code which should never see the light of day.

Accelerated Agile

preconference tutorial: 360 minutes
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

Agile for Quantified Value Delivery

preconference tutorial: 360 minutes

Conventional Agile is focused on high velocity code delivery, not measurable multiple value delivery.

This tutorial will detail a practical set of tools for managing conventional agile programming, so that it is focused on delivering measurable value streams to stakeholders.

The key, and tutorial focus is a mind tool. The mind tool is a quantified Planning Language. The Language articulates all quality attributes quantitatively, as well as other, performance attributes of all designs, architecture ideas, and strategies. This is a basis for Architecture Decisions and Quantified Agile Project Management (Evo)

One major London Financial Institution has made this method a standard for managing all types of Agile Development processes they use.

This tutorial will raise your game from ‘programming’ to making sure your programming produces valued results, early, frequently and measurably: so that your management can more clearly appreciate your projects real value to them.

Do you want to be a dev forever? Or are you ready to consider being a real software engineer?

We will teach the following practical tools:

  • 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)
  • The corresponding discipline of estimating the design costs in several dimensions such as capital expenditure, calendar time, and human resources.
  • The use of the Value Decision Table discipline, for articulating the quality of estimates: +- uncertainty, % of Goal or Budget, Source, Evidence, Credibilty, Safety Factor.
  • A take home detailed toolkit: Process and Specification standards: Procedures, Rules, Templates, Principles, for Architecture Engineering. Derived from the Competitive Engineering book (digital copy supplied free).
  • Case studies of use of the Agile ‘Engineering’ method
  • Application of Dynamic Design Prioritization; deciding the smartest thing to do each sprint, based on quantitative feedback, about costs and value actually delivered, on previous sprints and to date.
  • Project Management consequences: the Advanced Product Owner function.

An Agile Project Startup Week

case-studies: 90 minutes
Week: How to start any agile project in a single overview week, and get the basis for quick continuous measurable value delivery to customers and users, and other stakeholders.

Context: the startup week lays the essential groundwork for an agile project management process known as 'Evo'.

Day 1: Define the top ten most critical value improvements expected by this project, quantitatively on a single page.

Day 2: specify the top ten most powerful architecture or strategies for reaching your top ten project objectives on time.

Day 3: Evaluate the combined power of top architecture to reach the top objectives within budgets and deadlines. The impact estimation table (aka value delivery table) as a basic tool for determining the feasibility of meeting requirements within constraints: and for sensing risk levels and side effects.

Day 4: decomposition by value: finding initial value delivery steps for next and nearby weeks of attempts to deliver partial architecture and strategy, with a view to testing our ability to bring about real value improvement, or learn early of our limitations and lack of capability. Also the beginning of building or credibility, and communicating seriously with our stakeholders, and forcing our project team to recognize the whole system, not just the software alone.

Day 5. Getting management buy-in to diving in next week and starting to deliver real results. The irresistible proposition.

Case studies of doing this in practice, from UK (Citigroup), Norway (Confirmit), USA (Boeing, DoD) and other sources will be used throughout.

Why is a single week startup (feasibility study) sufficient to allow us to dive in and get results the next weeks? No matter project size (except perhaps the upper 5% most complex and large projects)

Automated Test Hell, or There and Back Again

case-study: 90 minutes
Almost 2 years ago we faced the fact that we are hitting the wall with our large scale automated testing of Atlassian JIRA - the product we have been developing in agile way for almost a decade. The cost of running and maintaining tests was growing exponentially. We analysed the problems and possible solutions and started the improvement program. Since then we've implemented a lot of significant changes and learnt new quite unexpected things. This session shows the findings from our journey - escaping from Test Hell - back to the (almost) normality. If you are interested in hearing what problems you can (and probably will) face if you have thousands of automated tests on on levels of abstractions (functional, integration, unit, UI, performance) across multiple platforms and what solutions can be applied to remedy them - this presentation is for you. You will learn that there are no sacred cows and your biggest problems may be hidden everywhere - including the least suspected place.
The session describes our story - the story of JIRA team (joint work of Atlassian teams in Sydney and Spartez team in Gdansk) which started religiously (or maybe not really) writing automated tests of all kinds (unit, functional, integration, performance) more than 10 years ago and which painfully learnt that what it means to maintain thousands of tests.

So the session explains how the XP promise of flat cost curve (in time) really means in practice (for us of course).

Whereas we use Java, the session does not concentrate on any language. It concentrates on engineering practices and reveals various pitfalls around writing, maintaining and running automated tests. You will hear about Continuos Integration, SCM (git), build system, dependencies, compilation times, coverage, etc.

I delivered similar presentation at a few conferences: part I (Getting There) - at 33rd Degree and GeeCON in 2012. Part II (Back Again) at 33rd Degree and XPDays 2013.

Behaviour Driven Development live session -From the idea to working software

workshop: 90 minutes
We all know how Behaviour Driven Development (BDD) should work from books, but can we apply all of its principles in real life? Is it helpful to apply? Is it worth it? If yes, then how can we build a working, high quality software from scratch? In this workshop we will see how can we apply BDD through a real life example. We will start with an idea. We will create the specifications in Gherkin language and code the solution using Test Driven Development(TDD). At the end you will have a clear understanding about BDD, TDD and how can you apply in your job. The example will be written in Java or C# based on participant's interest.

30 min presentation + 60 min live coding

Biological Realms in Computer Science

keynote: 60 minutes
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.

Building on Solid Foundations

presentation: 90 minutes
We know we're supposed to break code up into coherent parts, but many codebases just don't seem to get it right. To add some simple feature, we have to tear things apart or, worse, patch and work around the existing code. In a better system, it would just take a few lines of code to change our object graph. Why is it often so hard? We don't believe it has to be. We've seen other systems where the code is flexible enough to support the changes we need to make. This talk is about design principles that we've learned help us develop large-scale code structures that are easy to read and easy to change. At the lowest level, this means well-known patterns such as avoiding globals and following SOLID guidelines.

C++14 an overview on the new standard for C++(11) programmers

tutorial: 90 minutes
The standardization process of C++ accelerated. After C++11 we will have a bug-fix release in 2014. This talk will summarize the most important 'fixes' and new features that were introduced with C++14. It will not only list the features, but also show how these features simplify the life of a C++ programmer, especially one, that already adopted C++11.

The talk will also provide a quick overview on the things that didn't make it into C++14, but that will be available as so-called technical specifications (TS). While these are not fully standard yet, because some design changes might come, they are ready to try and to provide feedback, if something is not specified as one would expect it.

Among the C++14 language features covered are new syntax for numeric literals including binary numbers, fewer restrictions on the definition of constexpr functions and literal types, constexpr variable templates (not variadic!), more versatility on the use of auto in lambdas and return-type deduction for lambdas and functions.

While the C++14 library will not get std::optional<T> yet, it provides several improvements as well, for example, make_unique for std::uniqe_ptr, a quoted() manipulator for symmetric string I/O, exchange() to obtain a previous value from an assignment, flexible standard operator functors and user-defined literals for string, durations and complex numbers. For the template meta programmer, template aliases allow shorthands instead of ::type or ::value, easier use of tuples and complete iterator access, through global cbegin, rbegin, and rcbegin plus their corresponding xend functions.

C++ Best Practice - Designing Header Files

tutorial: 90 minutes
C++, shares information between translation units with a directive to insert text from a header file. This text is inserted with no regard for the surrounding context and, as a result, successful the use of header files relies on a number of conventions.

Novice developers rarely understand these conventions or the reasons for them. Most developers learn the conventions by a process of trial, error and imitation without always understanding the rationale.

Experienced developers rarely think about these conventions or whether they are being met in an effective manner.

Both novices and experts can benefit from a considered examination of:

the forces being balanced when designing a header file;
the resulting conventions; and,
the different ways these can be realized.

C++ Dynamic Performance

tutorial: 90 minutes
The tutorial continues the exploration of C++ type erasure solutions, this time with emphasis on detailed performance comparisons between various library solutions as well as performance improvements that can be achieved when new C++11 features are employed. Session will cover the 'usual suspects' - dynamic typing solutions from from Boost, Poco and Facebook C++ workshops, with the addition of QVariant and main emphasis on performance analysis.

While type safety is an important feature of C++ and type erasure a necessary technique for modern software development, performance inevitably suffers during data conversion operations. Session presents measurement results on different compilers and platforms, examines and compares performance penalties incurred and gains achieved through employment of C++11 features.

C++ Pub Quiz

tutorial: 90 minutes
Join us for a pub quiz on C++! You will be working in groups where I present interesting code snippets in C++ and you will discuss, reason about and sometimes need to guess what the code snippet will print out. There will be many educational snippets where we elaborate on the basics of C++, but some of the snippets will be really hard with surprising answers and where we explore the dark and dusty corners of the language.

Some knowledge of C++ is essential, while experience with compiler development and eidetic memory of the C++ standard is very useful.

C++ Undefined Behavior - what is it, and why should I care?

tutorial: 90 minutes
More and more people are becoming aware of undefined behavior (UB) in C and C++. It has become a research interest at several universities, and code generators routinely use information about UB when deciding how to optimize code. In this talk, I will give examples of UB, show how optimizers reason about UB while doing code generation, and talk about strategies to avoid introducing UB into your code base. Finally, I will talk about the current (and upcoming) tools for detecting UB in existing code.

Clojure is the new C

tutorial: 90 minutes
Why do we love C? Many reasons. Among them are it's simple syntax, it's minimal semantics, and it's closeness to the hardware. But for the last decade we have been transitioning into an era where the hardware doesn't matter. Who, 30 years ago, would have thought that the majority of enterprise applications would be executing on virtual machines; and that a plurality would be using interpreted languages?

Hardware is no longer the constraint that it was. And this trend will only continue. Therefore, what language is just like C, but without the closeness to hardware? Which language has a simple syntax and a minimal semantics?

I'll make the case for Lisp - specifically for Clojure.

CoderDojo and Self Organization

keynote: 60 minutes
Consumer software thrives when a certain cocktail of ingredients are applied to the UX/UI. These principles of design which include scale-free self-organizing systems were applied to CoderDojo as an organization and the impact has been global and continues to expand. Speaking about the design of the system that makes CoderDojo work Bill will share insights that are applicable to any consumer software that wishes to achieve significant reach.


preconference workshop: 360 minutes
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.

Comfortable concurrency

tutorial: 90 minutes
Reflections on what is comfortable and uncomfortable about developing concurrent software.

What makes for 'comfortable software', that is to say software that is comfortable to work with? In this talk, Dominic Robinson will take a look at different models of concurrency, their applicability and impact on your comfort as a developer.

Topics you will learn about include:
- Concurrency vs parallelism.
- How do you make working with concurrency 'comfortable'.
- Message passing concurrency, or 'Atomics considered harmful'.

We will take a look at one implementation of message passing concurrency in C++ in a distributed fault tolerant application, the lessons and scars from the last 5 years, or 'they are coming for me with pitchforks and torches'.
- influences and motivation
- DSLs in C++
- how do we test this thing?
- how do we debug this thing?

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

tutorial: 90 minutes
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.

Continuous Delivery with Legacy Code

case-study: 45 minutes
Your team are invited to a meeting about their next exciting assignment. The company's doing so well and taking so much money, that now the banks need you audit for PCI compliance. You start looking at what's involved in changing this vast legacy codebase to comply. What you discover is a labyrinth of code with many traps and even more secrets. This is a race against time with the threat of a looming fine, a tale of how a team worked their way through a maze, whilst still processing transactions and avoiding any big bangs.

The case study will take you through how we recently took up this challenge and extracted functionality from a tightly coupled legacy code base into a secure card data environment. The refactorings were continuously deployed and the code was constantly in use. Along the way we will define what legacy code is, illustrate the challenges involved in refactoring old code bases and note how fully tested code isn't as easy to change as we were lead to believe.

Cool and Ripe for Exploitation: Search-Based Software Engineering (SBSE)

case-study: 90 minutes
Once in a while, a very good idea comes along. When explained, we might wonder why we didn't think of it before. For instance, many software programming tasks involve making trade-off judgments between conflicting needs. Should my code be robust or fast? Should it be rock-solid or is the need to ship to market more pressing? Should the focus be on short- term expediency or respectful of long-term architectural needs? To balance the trade-offs, it's typical for programmers to iterate over many possible solutions and evaluate them, incrementally moving through a number of possibilities until a satisfactory solution is found. With the recognition that what's happening here is a manual search though a space of possibilities, the very good idea is that this search activity can be emulated in software. The purpose of this is not to totally automate programming, replacing the human programmer. Rather, by emulating the search process, the programmer is supported by being shown solutions that they might never have considered because of the sheer quantity of possibilities to explore. In the past five years, there's been an explosion in the number of search-based approaches put forward to support the programmer, and they show great promise. In fact, it turns out that computational search-based approaches have been successfully applied to not only searching source code solutions, but also automatic refactoring, automatic test case generation and even automatic bug-fixing.

This case study starts with an explanation of how search-based approaches work generally, and goes on to provide an insight into some of the fascinating and novel applications of automated search-based software engineering (SBSE) available to the programmer. Finally, the case study offers some signposts for 'quick-win' computational search-based techniques for programmers to exploit and hence develop and improve their programming skills.

Crafting more effective technical Presentations

tutorial: 90 minutes
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.

Creating safe multi-threaded applications in C++11

tutorial: 45 minutes
C++11 finally establishes the mechanisms and libraries to create portable multi-threaded applications. 'Portable' meaning both to different OS environments as well as to different CPU platforms. Multi-threaded behavior got properly defined through a set of rules that constrain the freedom of the compiler and runtime to reorder memory operations. Deterministic application behavior is guaranteed when data races cannot occur. Avoiding data races in terms of C11 semantics is a complex topic that deserves explanation regarding atomics and acquire-release barriers. The complexity of creating correct multi-threaded programs necessitates verification through tools. Unfortunately, the toolbox of the C++11 programmer is still rather rudimentary in this respect. Among a few threading race detector tools, Google's 'thread sanitizer' is a highly promising public domain tool. It operates by building an order relationship among observed events, and can thereby report race conditions on program executions that otherwise would appear to behave fine. This model is a nice fit with the C++11 ordering semantics. A few interesting examples will be discussed.

Cultural Considerations for Working in the Middle East

presentation : 45 minutes
While the IT market is moribund in the USA and Europe there are ample opportunities in the booming Middle East. This talk will cover some of the basic cultural considerations that one must be aware of when embarking on and managing projects in this area.

Effective Pair Programming

presentation: 45 minutes
Pair programming is a central element in Extreme Programming (XP) and its correct practice dramatically improves software quality. The technique is however quite difficult to master, and not doing it properly will not only be frustrating for the developers but also a waste of the team and company resources. This talk introduces different approaches to the technique and shows the audience how to avoid the common pitfalls that developers will encounter in their path to effective pair programming.

Pair programming is a challenging practice, and though it is not a novelty, it is still surrounded by many misconceptions. I will step through DO's and DON'ts based on both documented and my own grounded experience on the topic, how it tightly fits other agile development practices such as Test Driven Development, and what to expect when introducing this technique in a team.

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

keynote: 60 minutes
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.

Exception Safety Guarantees in C++

tutorial: 90 minutes
When learning programming C++ there is the point where exceptions and try-catch are introduced. The classes I've seen just explain the language syntax around throw and catch, but don't go tell you that your code usually doesn't need try-catch. The talk discusses what the basic, strong and nofail exception safety guarantees are and how to implement them in C++ without much try-catch. Of course the 'resource aquisition is initialization' (RAII) principle will be the solution here.

In detail the talk will cover what STL containers and other classes do in case of exceptions and what that means regarding the exception safety guarantees. The distinction between copyable and move-only types is of interest here. Canonical implementations for copy/move constructors and copy/move assignment will be shown which enable to write own classes with value-semantics. This provides for exception safe use of these classes.

Executors for C++

tutorial: 90 minutes
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.

Extended XP Game

hands-on session: 90 minutes
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.

Fr-agile without good thinking

tutorial/workshop: 90 minutes
At my previous workplace supposedly SCRUM was used but I soon discovered that while the formal elements are there it's really something else, and doesn't work either. So I held a series of seminar sessions to look at the thinking patterns, the underlying philosophy it was originally built on. What in surprisingly short time lead to streamlining the process and extreme boost to the productivity, while the team found that work changed from grind to be fun.

Here I try for a condensed version. I introduce the Lean thinking house (respect for people and continuous improvement). Discuss the agile and SCRUM values (openness, focus, courage, commitment, respect) and the agile manifesto to dig for the true meaning and the usual misrepresentations. And how all that maps to an actual development process making or breaking it. Another focus point is 'self managing team', what is tricky to get at, especially if old command&control habits are kept in effect.

The session is interactive, addressing practical objections, looking at success and failure stories from experience. I hope the audience will join in, those who were sitting in that chair, are there now, or play with the idea of a process change. I hope collectively we can come out a little wiser and more enlightened. I especially invite skeptics and those with bad experience with 'turning agile' or just breaking from direct leadership forms.

Generative C++: Visualizing Code

case-study: 90 minutes
The code you work on is often a complex mass; never is the documentation a true reflection of the code. Existing brown field work is almost void of any engineering diagrams that reflect the composition of the code base.

Using clang as a source code analyser it is easy to generate diagrams via technologies such as graphviz, XMI, gnuplot, or even Visio! (Seriously, drawing diagrams in Visio with a mouse is not for the impatient.)

We show you how to use clang to generate detailed:
Entity relationship diagrams.
Sequence diagrams.
Dependency diagrams.

But you can also generate diagrams that don't really have a formal name but are useful to you, from tracking the lifetime of a message object in a multithreaded application through to analysing the evolution of that object in source control history. The point is that using clang you can completely specify the analysis that you want.

Generic Programming with Concepts Lite

tutorial: 90 minutes
In this talk, I will give an overview of the Concepts Lite language extension for the C++ and present examples of its use in the design and implementation of real-world generic libraries. Concepts Lite provides the ability for programmers to directly state constraints on template arguments as part of the template declaration. These constraints are predicates that determine whether or not a template argument can be used with that template, and they are checked by the compiler at the point of use, not unlike an asserted precondition, meaning that that effectively constrained generic libraries will not suffer from the usual problems of insane diagnostics. Moreover, libraries written using Concepts Lite are more readable, maintainable, and elegant.

While Concepts Lite is straightforward and easy to grasp, early experience has shown that some retraining is required to use the features effectively. Current techniques used in generic library construction are made practically obsolete by Concepts Lite. The effective and principled use of Concepts Lite is rooted in the definition of predicates as logical expressions and their implications. Advanced language rules and programming idioms like SFINAE, type traits, and metaprogramming are no longer required to design and implement good libraries. Examples will be presented from the Origin C++ Libraries, the first large-scale application of Concepts Lite to generic library construction.

Concepts Lite is a forthcoming ISO Technical Specification (TS) aimed at publication alongside C++14. Concepts Lite is implemented in a branch of GCC, which will be made available to the audience for experiments and experience.

Git archaeology

tutorial: 90 minutes
Source control is all warm and fuzzy in day-to-day to development but it should really come into its own when things are going wrong.

Paradoxically, the need to delve into the past is frequently triggered by urgent events in the present. Something has gone wrong, but what caused this failure? What changed recently? How long has this function been coded like this? What other releases is this issue likely to affect?

Git comes with powerful tools and features that help answer some of these important questions and this session is aimed at giving an overview of what tools are available and how to use them via live demonstrations with real world repositories.

Tools tested in anger include:

- log: an underrated tool that has a plenty of options to help narrow down ranges of suspect commits by author, log message contents, or the content of the change itself.

- blame: a potentially useful tool that can be a little frustrating to use. There are ways to help extract the maximal amount of useful information from it.

- bisect: a powerful tool that can quickly track down a simple error or to grind through extensive automated tests to find well hidden regressions.

Growing Games Guided by Tests

interactive workshop: 90 minutes
This interactive workshop will not only give an introduction to game development to the attendees, but also will reveal the techniques of building truly testable games. We will be using unit tests, integration tests and acceptance tests as our guides and safety net. We will change the requirements and make changes in the code. We will refactor the code. And finally we will play the game! Everyone can build a game and we will prove this in 90 minutes.

It's an interactive session and those who will install a free version of Unity3d to their laptops would be able to follow me using the open source examples and tools provided. The examples for this session would be available in C# and JavaScript.

#define hell in multi-platform embedded programming

presentation: 45 minutes
A lot of projects face the challenge that the source code has to be compiled for different targets. Either the same SW has to be compiled for different CPUs or slightly different code has to be compiled for the same CPU. In some projects the same binary code has to run on several different HW platforms, but behave differently. In this presentation we look at different ways to solve these problems. The presentation is based on the experience of a 8 year project with 15 different build targets.

He's Not The Messiah! Cinema and myths of leadership

workshop: 90 minutes
At the climax to Peter Jackson's film "The Return of the King", Aragon leads the remains of his army to the Black Gates of Mordor. He delivers a stirring speech to his forces before launching a final attack, providing the diversion that allows Frodo to achieve his goal. The curious thing about this speech is that it's not in Tolkein's story. Why did Jackson and his screen-writers feel they had to invent one?

Cinema, and thus popular culture, has conventions on how leaders behave. But these conventions are mythological, not factual. And if we're involved in working in a real life team, they may not be helpful.

In this session we'll look at the myth and the reality of leadership, and its rarely considered counterpart, followership. We'll watch some film clips, and debate leadership in the world of the software team.

HOWTO - The Brain

presentation: 45 minutes
This is a talk to give people a better idea on how to maintain their mental health. It also deals with varying degrees of mental ill-health and how a sensible life style can either prevent or mitigate mental ill-health. It also explains how to get the most from your brain (essential for a software developer) and how to improve your brain as well.

Immutabilty FTW!

tutorial: 90 minutes
"When it is not necessary to change, it is necessary not to change" observed Lucius Cary, four centuries ago. He could well have been talking about program state (had such a concept existed). We have it by the bucket - by the megabucket, gigabucket and terabucket - and most code, designs and programming languages assume that program state is something that is changeable. But should it? Is this assumption always valid? Is state change as necessary as its widespread use might suggest?

Immutability is a cornerstone of pure functional programming, and is often seen to be exclusively associated with it, but immutability and other restrictions on state mutability are more widely applicable, and certainly not the sole preserve of functional languages. It is a necessary practice in languages with reference-based semantics and in concurrent environments, for example. Without it, code becomes difficult to reason about (oh. . .) or chock full of locks and deadlocks (ah. . .). This loss of simplicity may seem familiar.

This talk looks at the consequences, benefits and implications of programming in an immutable or less mutable style, including techniques both large and small that can be applied in mainstream languages and existing systems.

Java is Dead, Long Live Scala, Kotlin, Ceylon, etc

presentation: 90 minutes
Java 8, a huge revolution is Java, is due 2014 Q2. But is it too little, too late? Scala, Kotlin and Ceylon are statically typed languages designed as replacements for Java (*). Instead of trying to force a 1990s stripped down C++ to be a modern programming language, they start from scratch with only the JVM and the Java Platform as fixed points. Can these languages gain market penetration against the entrenched Java? In this session we will consider some of the technical issues, leaving the socio-political ones at the door. A surprising candidate language will also make an appearance - to create an element of suspense, it will not be named at this time.

(*) In a world that seems obsessed with JavaScript, it is worth noting that Ceylon as well as Dart (and to a lesser extent Kotlin and Scala) are able to treat JavaScript as a target, providing programmers with a better language to program systems that are browser based.

Just Enough Haskell to be dangerous

workshop: 90 minutes
In this workshop, we'll introduce Haskell with no prior knowledge assumed. We'll start by learning just enough syntax to be dangerous and then we'll jump straight into solving some problems in a functional style!

You'll start by learning how to read Haskell type definitions. You'll see how powerful type signatures are, and learn to have conversations with the compiler to fill in the blanks. You'll move on to defining your own types and see how types prevent errors.

Finally, we'll put it all together and build a simple combinator library for analysing a dataset.

By the end of the workshop, you'll be able to read Haskell type signatures and have a base from which to build your Haskell knowledge. Even if you can't use Haskell in your day job, you'll definitely be able to translate some of the ideas from this workshop into your language of choice.

Prior to attending this workshop, you should make sure that you've got the Haskell Platform installed and a sensible text editor (you'll be pairing, no Emacs/vi wars please!).

Lambdas and Streams in Java 8

presentation: 90 minutes
Java 8 comes with several new language features. First, there is support for expressing anonymous functions: Java 8 has lambda expressions and method/constructor references for this purpose. Second, interface methods can have an implementation in Java 8: there are default methods and static methods in interfaces in addition to the well-known abstract interface methods.

Lambda expressions are essential in conjunction with new JDK abstractions such as Stream, ComputableFuture and the like. These new JDK APIs are clumsy to use without lambdas and method references. The non- abstract interface methods were used for the design and implementation of the new JDK APIs. The JDK's collection framework is radically overhauled in Java 8: it has bulk operations that take functions and apply them to all elements in a collection. The session provides an overview of the new operations and some insight into their inner workings. The centerpiece of the new API is the interface We will explore what streams are, how they differ from collections, how their operations are executed (in parallel or sequentially), why some operations are intermediate and others terminal, why most operations are stateless, and what fluent programming is.

Audience: Java developers with an interest in Java 8.

Level: intermediate

Prerequisite: basic knowledge of Java

Lambdas and Streams in Java 8

preconference workshop: 360 minutes
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

Large-Scale C++ - Advanced Levelization Techniques

presentation: 90 minutes
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience.

In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.

Let's talk about sets

case study: 45 minutes
This session starts with a bug report. Subsequent investigations take us back through the history of a codebase, and of C++ itself, uncovering some wrong turns and awkward truths. The bug is resolved, fixed, but questions remain.

Lies, damn lies, and estimates

tutorial: 90 minutes
Are estimates an essential part of project planning and delivery or a waste of everybody's time? As is so often the case the answer is neither and both. In this session we discover that there is more than one kind of estimate and examine how they are typically used in an agile context.

We look at what some of the great minds have said on the subject, from Steve McConnell to Demarco and Lister. We'll also consider the need for estimates from the viewpoint of the business people who have to decide whether a project proposal should receive budget. Picking up the 'No Estimates' discussion from Twitter, we'll see if there's a case to be made for always refusing to provide estimates or whether there are times that some sorts of estimation is valuable.

And we'll end by considering what Disraeli might have said on the subject.

I may not change your mind, but I intend to widen your perspective.

- Based on an article written for ACCU's Overload magazine
- With short practical exercises for attendees

Long Life Software

presentation: 90 minutes
Civil engineers build structures to last. Aerospace engineers build airplanes for the long haul. Automotive engineers build cars to last. How about software engineers?

Not all of software needs to be engineered for long-life, but in some systems the predicted market span dictates we plan for the future. How can we do this, given the uncertainties in the technology industry?
What can we learn from the past?
How can we take informed bets on technologies and plan for change?
This session will cover some of the important technical considerations to make when thinking about the long term.

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

experience report: 90 minutes
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.

Machine Learning for Fun and Profit

presentation: 90 minutes
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.

Matchbox Scalable Test System

presentation: 45 minutes
Matchbox is our home grown continuous integration system used for most of Cisco's TelePresence products. It enables hundreds of developers to successfully maintain and develop a large C and C++ codebase supporting advanced embedded products running on a wide range of hardware platforms. This talk will focus on the considerations and design choices that has been implemented in Matchbox since we started using it 9 years ago. We offer a lot of lessons learned that you will find useful if you want to grow your own.

Mens sana in corpore sano (a healthy mind in a healthy body)

tutorial: 90 minutes
Our minds and bodies do not exist in isolation. Even the Romans knew that. What the Romans didn't know was how our modern lifestyles - especially in sendatry professions such as ours - would throw the balance between them into crisis!

Just going to the gym 2-3 times a week (if we even do that) is not going to cut it. Many studies have shown that changes need to go much deeper - with NEAT (Non-Excercise Activity Thermogenesis) playing a major role. Our diet, too, is critical to getting the best out of, not just our bodies, but our minds too. Doing the right things the right way can literally be a matter of life and death!

The good news is that, with the right information, making the necessary changes is not only realistic but can be fun and enjoyable. You can expect to feel better, to think better, to get sick less and extend your life! It *will* take some committment, but not the setting-yourself-up-for-fail type you might be used to.

The problem is that there is a lot of misinformation out there, as well as out-dated, counter-productive, views (many of which are still promoted by the state - although that is changing). Previous unfruitful attempts to adopt a healthier lifestyle may put us off trying again. But often the lack of success was down to just having the wrong information. We'll look at how to make sense of all this and how to avoid as many of the wrong paths as possible.

This presentation aims to cut to the heart of the best, scientifically supported, models we have of how to get - and stay - healthy in our modern environment and in the types of jobs we have. As well as general information and statistics I'll also cover some of my own anecdotal experience - including how, despite years of failure previously, I've been able to sustainably loose, at time of writing, over 25kg (about 4 stone) in just a few months (I expect to be at or near my ideal weight by the time of the conference) and feel better than I have for twenty years!

We'll cover NEAT and how it relates to sitting, standing and walking, some key principles of nutrition - including a crash course in the chemistry behind it - and how to get (and stay) fit despite our full schedules. Along the way we'll bust plenty of myths and take advantage of our existing motivation to maximise efficiency and effectiveness and automate as much as possible.

Mock that Legacy C - Hands on

preconference workshop: 360 minutes
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.

No estimates and probabilistic planning

workshop with presentation: 90 minutes
This year has seen the rise of the noestimates movement. This workshop will explain the arguments for and against noestimates and will tie it into the probabilistic planning techniques that are emerging from the kanban community.

None of the ideas presented here are new - they are just forgotten from time to time

tutorial: 90 minutes
In the software development world we seem to have a short memory coupled with a propensity to miss potentially interesting information coming from other fields. For these reasons we often re-discover well known things - a case in point are people re-discovering some management principles and re-branding them 'agile', but there are quite a few other examples around. The purpose of this semi-serious and interactive session is to have some fun, but also to remind us to stop and think before falling for the next new thing...

OpenMP 4.0 A New Standard in High Level Parallelism

tutorial: 90 minutes
The OpenMP 4.0 API supports the programming of accelerators, SIMD programming, and better optimization using thread affinity

The OpenMP Consortium has released OpenMP API 4.0, a major upgrade of the OpenMP API standard language specifications. Besides several major enhancements, this release provides a new mechanism to describe regions of code where data and/or computation should be moved to another computing device. With this release, the OpenMP API specifications, the de-facto standard for parallel programming on shared memory systems, continues to extend its reach beyond pure HPC to include DSPs, real time systems, and accelerators. The OpenMP API aims to provide high-level parallel language support in C, C++ and Fortran for a wide range of applications, from automotive and aeronautics to biotech, automation, robotics and financial analysis.

New features in the OpenMP 4.0 API include:

Support for accelerators. The OpenMP 4.0 API specification effort included significant participation by all the major vendors in order to support a wide variety of compute devices. OpenMP API provides mechanisms to describe regions of code where data and/or computation should be moved to another computing device. Several prototypes for the accelerator proposal have already been implemented.

SIMD constructs to vectorize both serial as well as parallelized loops. With the advent of SIMD units in all major processor chips, portable support for accessing them is essential. OpenMP 4.0 API provides mechanisms to describe when multiple iterations of the loop can be executed concurrently using SIMD instructions and to describe how to create versions of functions that can be invoked across SIMD lanes.

Error handling. OpenMP 4.0 API defines error handling capabilities to improve the resiliency and stability of OpenMP applications in the presence of system-level, runtime-level, and user-defined errors. Features to abort parallel OpenMP execution cleanly have been defined, based on conditional cancellation and user-defined cancellation points.

Thread affinity. OpenMP 4.0 API provides mechanisms to define where to execute OpenMP threads. Platform-specific data and algorithm-specific properties are separated, offering a deterministic behavior and simplicity in use. The advantages for the user are better locality, less false sharing and more memory bandwidth.

Tasking extensions. OpenMP 4.0 API provides several extensions to its task-based parallelism support. Tasks can be grouped to support deep task synchronization and task groups can be aborted to reflect completion of cooperative tasking activities such as search. Task-to-task synchronization is now supported through the specification of task dependency.

Support for Fortran 2003. The Fortran 2003 standard adds many modern computer language features. Having these features in the specification allows users to parallelize Fortran 2003 compliant programs. This includes interoperability of Fortran and C, which is one of the most popular features in Fortran 2003.

User-defined reductions. Previously, OpenMP API only supported reductions with base language operators and intrinsic procedures. With OpenMP 4.0 API, user-defined reductions are now also supported.

Sequentially consistent atomics. A clause has been added to allow a programmer to enforce sequential consistency when a specific storage location is accessed atomically.

Order Notation in Practice

presentation: 90 minutes
Many of us are familiar with the "Big O" order notation for giving an idea of the complexity of algorithms; for example the C++ std::sort function is described as "N logN". But sometimes this can seem a little unconnected to the task of actually writing code.

I'll use some examples where there are multiple ways (with different complexity measures) of solving the same problem to explore a few questions, such as:
What does complexity notation actually mean?
What does this measure *not* tell us?
How important is this in practice?
What other considerations are also important to consider?

Parallel Processing for Accelerated ALM and CI - Better, Faster and More Cost-effective Software Development

tutorial: 45 minutes
Organizations are trying to automate and streamline the software building process for a competitive edge. The process of releasing new software can be complex and lengthy. A rapid feedback cycle that notifies whether the latest build of the software passed successfully or not can often mean the difference between rapid detection and amelioration of product defects or not discovering those defects until later in the project's lifecycle, exponentially increasing the cost and difficulty of fixing them.

Most workflows are done sequentially, using a single CPU core. This means performance improvement requires increasing the speed of the CPU for computational processes, and the IO capabilities for IO-bound processes, such as reading and writing to the file-system or network.

Moore's Law is often understood to refer to the raw computing speed in the form of the chip's clock speed. The heat generated by 4 GHZ CPUs is too great and too difficult to dissipate so CPUs' clock speeds remain just over 3 GHZ. Therefore, chip manufacturers diverted their efforts from making faster CPUs to making CPUs with multiple computational cores.

Why is this relevant? The free lunch is over. While as a software developer, you could in the past simply throw more hardware at speed-related performance issues, this is no longer possible. You cannot simply do things faster; you need to do them in parallel, which requires effort. We'll discuss the options, such as:

Improving build processes with multicore CPUs
Parallelization options
Process virtualization
Scaling your build process performance

Performance Choices

tutorial: 90 minutes
When programming there are always these small choices: write code one or another way. When the required behavior can be achieved in different ways we need to choose and many criteria are rather subjective. Choosing the fastest approach is a relatively obvious and objective solution which other choices can, at least, be measured against. The presentation discusses a number of specific aspects where there are typically many implementation choices and tries to quantify the cost of the different choices, taking different hardware, compilers, etc. into account. Since C and C++ are focussing on performance, the goal is to identify techniques where small changes in how the code is implemented can have a comparatively large impact on performance. The various programs used for the comparisons will be available to allow verifying the results or determining which of the results are applicable to a platform not covered.

Polymorphic Allocators for Fundamental Libraries

presentation: 90 minutes
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.

Random number generation in C++ - present and potential future

tutorial: 45 minutes
Random numbers are numbers that appear in random. They are one of the fundamental tools in numerous numerical works such as simulating graphics, extrapolating financial data, smoothing digitalisation and forecasting the weather. Initially random numbers were generated by tossing coins, throwing dice and spinning roulette wheels. Later, random numbers were generated using nuclear radioactivity, voltage fluctuations and atmospheric noise, etc. These physical methods were expensive and time consuming. Therefore, computational methods were devised for generating random numbers. Computational random numbers were produced by using algorithms, which were not truly random numbers, but they possess the property of randomness. Hence, they are called pseudo-random numbers. A function called rand() was implemented in C language to generate pseudo-random numbers and that is adapted by C++.

In C++11, a great leap has been made by incorporating very successful pseudo-random number generating algorithms, viz., linear congruential, subtract with carry and Mersenne Twister along with several analytical distributions. For C++17, consideration is being given to incorporate quasi-random numbers such as Halton and Sobol sequences. The quasi-random numbers are not like the randomly distributed numbers of pseudo-random numbers, rather the numbers are generated in a way to fill the gaps in the previously generated distribution.

In comparison to pseudo-random numbers, the quasi-random numbers are advantageous in a sense that the later needs relatively far little iterations to achieve desired accuracy in numerical calculations. Concurrent generation of random numbers in CPU/GPU boosted the excitation of achieving reliable Monte Carlo calculations in short time. The talk is intended to elaborate the principles, properties, pros and cons of the random number generation methods and their relevance in concurrent Monte Carlo simulations.

Range and Elevation - C++ in a modern world

tutorial: 90 minutes
As programmers we spend a lot of time and effort dealing with collections of … stuff. Words, numbers, files, Employees, you name it, we have collections of it. C++ provides some pretty sophisticated tools for managing collections, but they are, in truth, pretty low-level, and not altogether intuitive. Other languages seem to do better in this regard, although sometimes with an associated cost in either time or space. How hard would it be to raise the bar of abstraction in C++ without sacrificing efficiency?

This talk is about my attempt to do just that, through an API of simple, but composable expressions geared around some of the more common needs of code that works with collections of … stuff.

Software Imaginations

presentation + discussion: 90 minutes
Following on from my talk at ACCU last year on Phenomenology and Software Development, I shall give an initial 30-45 minute talk exploring some existing philosophical ideas about imagination, followed by a "goldfish bowl" style discussion format for participants to share how this relates to their inner experiences of designing and debugging software systems.

The talk will not be a presentation by someone with all the answers - it is there to foster a co-exploration of the role that imagination has to play in software development.

The idea for this session has been based upon my observation that in the workplace there has been an unprecedented transition from physical work to internal, knowledge-based, work and in the case of programmers, dealing with non-physical constructs.

Yet just how aware are we of this fact? How do we see the development of the skills in dealing with this inner world's dynamic?

I am hoping that this session will give pointers to how we can improve the way we communicate about our inner processes in a way that makes sense for the outer work we produce.

In the talk I will gather insights from the likes of Kant, Goethe, Henri Bortoft and Christopher Alexander. I welcome those who have the courage to literally take their hearts into their hands and dive into this inner world from a practitioner's viewpoint.

Software Quality Dashboard for Agile Teams

case-study: 45 minutes
It is common knowledge that prevention is better than cure; built-in quality and good design is more efficient than thorough regression testing and bug fixing at later stages of development cycle. Yet it is not uncommon to see complex code that has gone well beyond the point of no return, when it's no longer feasible to support any further development.

This presentation will describe a system for continuous monitoring of software quality metrics that we have built on top of CI server, and how it is used to effectively manage technical debt and external quality attributes in an agile environment, keeping it within healthy boundaries and avoiding degradation. We will discuss code metrics (test coverage, c. complexity, code coupling, etc.) that we monitor and what ranges and trends we found useful for a software house with a number of relatively small and often independent C#/C++ projects. We will also review Lean and Agile techniques and freeware tools (CruiseControl.NET, SourceMonitor, FxCop, Atomiq, internet TV screens, etc.) that we employed in the development process.

SOLID Design for C

tutorial: 90 minutes
C does not have to be spaghetti code. It can be modular and flexible if you apply the SOLID design principles. In this tutorial, we look at applying Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation and Dependency Inversion principles to C. SOLID gives good guidance on modularity and coupling; these principles are not just for programmers with an OO language.

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

preconference workshop: 360 minutes
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.

The Art of Learning and Mentoring

presentation: 90 minutes
Similarly to design patterns, pedagogical patterns present solutions to recurring problems in a given context. The wider context for the pedagogical patterns is teaching and learning, especially of technical subjects.

In this session, I want to explore how pedagogical patterns can help every individual to get better every day. Although we are often unaware of it - learning and teaching is part of the daily work of every team member. Thus, I want to show how these patterns can help to be a better mentor and therefore help the whole team to improve continuously. This might be what you were missing. Here are some of the tools you need in order to share experiences, learn from one another or rather to start mentoring consciously in your team.

The pedagogical patterns show you ways to learn actively and experientially, to give and take supportive feedback and to look at problems from different perspectives. Although originally developed for a training situation, these patterns are a wonderful source for all kinds of learning: individually, when pairing, and during meetings like review or retrospectives.

The biggest mistakes in the C++11 library

presentation: 90 minutes
What we found out to be broken in C++11

The C++14 Standard Library

tutorial: 45 minutes
This year will see the publication of a new C++ standard. The changes in the library are mostly small, incremental improvements to existing components, but they make a big difference to usability and convenience for anyone using C++11.

The continuing future of C++ concurrency

tutorial: 90 minutes
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

The Evolution of Good Code

presentation: 90 minutes
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.

There Ain't No Such Thing As A Universal Reference

tutorial: 45 minutes
Scott Meyers coined the term "universal reference" to describe a feature of templates in C++11, but the C++ standard only talks about lvalue references and rvalue references. This session will explain what is meant by "universal reference" and demonstrate that the feature depends on simple rules of C++ that are independent of templates. The aim is to clearly explain the underlying concepts in terms of the rules that the standard and your compiler use, so that you know what's really happening when you use and write code containing "universal references".

Unit Testing Beyond Mock Objects

tutorial: 45 minutes
Unit testing is a well-established practice today. Mocking frameworks are plentiful and available for almost every programming language. We have learned to design our system to make the most of unit testing. We have invented techniques to test our code even when it interacts with the runtime environment and third party libraries that are not designed for mocking out. But there are still obstacles.

This talk will look at a new generation of mocking frameworks that let us mock out static methods, create objects of classes without public constructors, etc. With these tools we can create unit tests for classes that for example use system time without introducing a mockable time provider class and allow our mock methods return mock objects of concrete classes. The focus will be on Java and C#.

Version Control - Patterns and Practices

tutorial: 90 minutes
After the text editor and programming language the next most valuable, hotly debated and often poorly used tool is probably the version control system. Some treat it as nothing more than an ad-hoc backup of their source code whilst others endeavour to create a narrative that describes the evolution of their entire software product from inception to decommission.

This session takes a walk through the software development lifecycle and examines the role the source control system plays - what we store, why we store it, how we change it and then later how we reconstruct what was changed and why. We'll look at the various forces that dictate our branching (and subsequent merging) strategies along with some of the less contentious policies we can adopt to ensure our system continues to evolve reliably whilst maintaining a traceable narrative.

Despite the range of commercial and open source SCM products out there the patterns and practices I will discuss here are almost universal. For the Software Archaeologist preserving history across file/folder moves and renames is just one aspect where tool specific knowledge matters. But before we can get there we need to deal with their lack of agreement on a common vernacular. . .

We make Hardware! - A story of Introducing an Agile Ecosystem in Embedded Software Development

case-study: 90 minutes
Most embedded system projects today try to achieve stability by freezing requirements, hardware/software architectures and schedules in the initial phase of the project. This is remarkable, as nowadays embedded markets are highly volatile, and well known to make unexpected turns. Reasonably, changing product requirements, time-to-market constraints and rapidly evolving technologies are today's challenges in embedded software development - just as in the business software counterpart. For the latter, compelling evidence exists by now that Agile methodologies offer an answer to these challenges, showing significant cost savings and quality improvements.

In this talk, I will discuss the case study of a successful introduction of Agile in an embedded environment. The focus of the talk will not be Agile itself; rather, I will show how an Agile ecosystem was build, where several new and well known techniques co-exist, and where synergies between these techniques can be identified.

First, I will explain how Model Driven Development (MDD) fits naturally with Agile, rather than being diametrically opposed to each other as sometimes heard. The UML model is the communication hub between the different stakeholders, going from the architects, developers and testers all the way to the customer. Secondly, I will show how a so-called Execution Framework (XF) is crucial to allow a simple one-to-one mapping between the (behavioral) UML models and the code, ensuring that the code can easily catch up with a changing model. Next, some additional benefits of the usage of an XF are shown: An XF can be used to make early software prototypes, allowing the customer to explore e.g. the user interface long before the actual hardware is ready. This fits within the Agile spirit of early and continuous delivery. Also, an XF operates purely on an event driven basis. This allows any user to "record" the events when exercising a certain use case. This recording can be visualized again (e.g. in a UML sequence diagram), serving as a great aid in debugging for the developers. Alternatively, it can even be played back on different hardware (a PC e.g.) where it serves as a system/unit test for the continuous integration server. Finally, it will be explained how the recording can be used as a Data Range Specification (DRS) for formal verification tools like Polyspace, often used in embedded software.

What Programmers Want

workshop and presentation: 90 minutes
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 programming experience, so I will give you the chance to try it out for yourself.

Acknowledgement: My research would not be possible without the generous help of my participants. My heartfelt thanks to ACCU for allowing me to recruit at the 2013 conference, and to everyone who volunteered to take part.

Where is C++ headed?

presentation: 90 minutes
How is C++ is different to other languages and how does that affect the way we write and think about programs? C++11 adds a host of new language ideas that build on these differences and C++14 extends things yet further. Key questions to explore are: how do these new features change how we think about C++? What standard design idioms and techniques should we consider changing and what new ones should we explore? How can we take advantage of the new without abandoning the old? As C++ enters a new era and enjoys a new burst of energy, this talk seeks to explore how we will live and learn in this exciting new world.

(This is an extended version of the talk that I'm giving in December at NDC London.)

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

keynote: 60 minutes
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.

Words in Code

tutorial: 90 minutes
As software developers we do not just write code. We write many, many words too.

We write documentation, comments, manuals, specifications, technical articles, wiki documentation, and more. Maybe even magazine articles and books.

This talk discusses some practicalities of writing well, both stylistically and practically. We'll talk about prose, but also about the right "geek" way of writing, the storage formats, toolchains, and the storage of our words.

We'll cover:
- writing style
- what's appropriate: what to write what not to write
- keeping track: "source control" for words
- toolchains: what toolsets to use to write and prepare output
- markup languages vs "wysiwyg" tools
- sharing your words with non-geeks

At the end of this talk, you'll have a good idea how to put together an example "document toolchain" taking source-controlled words in a humane markup style, and creating high-quality HTML, PDF (fully styled, print-ready) ePub and Kindle output, as well as Word-friendly versions.