Abusing CSharp 5presentation: 90 minutes
Accelerated Agilepreconference tutorial: 360 minutes
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 Deliverypreconference 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 Weekcase-studies: 90 minutes
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 Againcase-study: 90 minutes
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 softwareworkshop: 90 minutes
30 min presentation + 60 min live coding
Biological Realms in Computer Sciencekeynote: 60 minutes
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 Foundationspresentation: 90 minutes
C++14 an overview on the new standard for C++(11) programmerstutorial: 90 minutes
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 Filestutorial: 90 minutes
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 Performancetutorial: 90 minutes
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 Quiztutorial: 90 minutes
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
Clojure is the new Ctutorial: 90 minutes
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 Organizationkeynote: 60 minutes
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.
Coderetreat!preconference workshop: 360 minutes
Comfortable concurrencytutorial: 90 minutes
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.Pythontutorial: 90 minutes
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
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 Codecase-study: 45 minutes
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
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 Presentationstutorial: 90 minutes
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++11tutorial: 45 minutes
Cultural Considerations for Working in the Middle Eastpresentation : 45 minutes
Effective Pair Programmingpresentation: 45 minutes
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
Exception Safety Guarantees in C++tutorial: 90 minutes
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
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.
This talk is for programmers and designers who are interested in some background for an asynchronous C++ world.
Extended XP Gamehands-on session: 90 minutes
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 thinkingtutorial/workshop: 90 minutes
Here I try for a condensed version. I introduce the Lean thinking house http://scalingsoftwareagilityblog.com/wp-content/uploads/2009/09/picture-3.png (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 Codecase-study: 90 minutes
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.
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 Litetutorial: 90 minutes
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 archaeologytutorial: 90 minutes
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 Testsinteractive workshop: 90 minutes
#define hell in multi-platform embedded programmingpresentation: 45 minutes
He's Not The Messiah! Cinema and myths of leadershipworkshop: 90 minutes
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 Brainpresentation: 45 minutes
Immutabilty FTW!tutorial: 90 minutes
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, etcpresentation: 90 minutes
Just Enough Haskell to be dangerousworkshop: 90 minutes
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 8presentation: 90 minutes
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 java.util.stream.Stream. 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.
Prerequisite: basic knowledge of Java
Lambdas and Streams in Java 8preconference workshop: 360 minutes
Audience: Java developers interested in the language extensions and collecton enhancements in Java 8.
Prerequisite: working knowledge of Java
Large-Scale C++ - Advanced Levelization Techniquespresentation: 90 minutes
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 setscase study: 45 minutes
Lies, damn lies, and estimatestutorial: 90 minutes
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 Softwarepresentation: 90 minutes
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 analysisexperience report: 90 minutes
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 Profitpresentation: 90 minutes
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 Systempresentation: 45 minutes
Mens sana in corpore sano (a healthy mind in a healthy body)tutorial: 90 minutes
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 onpreconference workshop: 360 minutes
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 planningworkshop with presentation: 90 minutes
None of the ideas presented here are new - they are just forgotten from time to timetutorial: 90 minutes
OpenMP 4.0 A New Standard in High Level Parallelismtutorial: 90 minutes
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 Practicepresentation: 90 minutes
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 Developmenttutorial: 45 minutes
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
Scaling your build process performance
Performance Choicestutorial: 90 minutes
Polymorphic Allocators for Fundamental Librariespresentation: 90 minutes
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 futuretutorial: 45 minutes
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 worldtutorial: 90 minutes
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 Imaginationspresentation + discussion: 90 minutes
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 Teamscase-study: 45 minutes
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 Ctutorial: 90 minutes
Switching to C++11 and C++14 in one daypreconference workshop: 360 minutes
The Art of Learning and Mentoringpresentation: 90 minutes
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 librarypresentation: 90 minutes
The C++14 Standard Librarytutorial: 45 minutes
The continuing future of C++ concurrencytutorial: 90 minutes
The Evolution of Good Codepresentation: 90 minutes
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 Referencetutorial: 45 minutes
Unit Testing Beyond Mock Objectstutorial: 45 minutes
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 Practicestutorial: 90 minutes
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 Developmentcase-study: 90 minutes
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 Wantworkshop and presentation: 90 minutes
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
(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
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 Codetutorial: 90 minutes
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.
- 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.