Agile Contracts: Building Trusttutorial: 45 minutes
Essentially the fixed price contract is based on the same assumptions about a fully predictable, easily planned future as the waterfall model. The Agile movement has gone a long way to breaking down such assumptions in the last decade, so that agile software delivery is now firmly in the mainstream. However, suppliers still often face a struggle to engage customers in a way which minimises contract negotiation and allows real collaboration to begin.
In this session we will look at a number of possible contract models which support an agile way of working to a greater or lesser degree, and explore the issues surrounding the procurement process. Can a contract form the basis of a relationship built on trust and mutual benefit?
Agile Teams: Value-Focused, Values-Drivenpresentation: 90 minutes
Allocators for Shared Memory in C++03, C++11, and Boosttutorial: 90 minutes
The talk commences with the definition and limits of the C++03 standard allocators and why it does not permit portable use of custom allocators for shared memory segments. The presentation continues with a discussion of the Boost.Interprocess allocator for shared memory. Examples will show the use of Boost containers in shared memory. Based on this knowledge the talk presents the C++11 allocators, how to implement a custom one, and how the latest standard enables new use cases for custom allocators. Finally the shared memory examples are reconsidered for comparing the old and new C++ standard.
An Exploration of the Phenomenology of Software Development.workshop/discussion: 45 minutes
The field has seen an unprecedented transition of a significant part of humanity from physical work to an internally oriented environment 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? How can we communicate about it in any way that makes sense?
I consider that the future positive, and human, progress of software development is dependent upon dealing with this ‘elephant in the room’ that few in our discipline (with some notable exceptions) want to talk about. I also propose that it cannot be done from a singularly results-oriented viewpoint.
Gathering insights from the likes of Wolfgang Goethe, Henri Bortoft, Richard Glass and also the recent work of Christopher Alexander, the speaker welcomes those who have the courage to literally take their hearts into their hands and dive into this inner world from a practitioner’s viewpoint.
Attendees will be invited to reflect about the inner processes of software development by considering what should be the familiar ground of various simple software design problems.
PS: This will be my first time at presenting at ACCU (gulp) although have been to a fair number of the conferences in the past.
Applied Hierarchical Reuse - Capitalizing on Bloomberg's Foundation Librariespresentation: 90 minutes
Creating a unified suite of multiple interoperable libraries also has many challenges in common with creating individual ones. The software should be easy to understand, easy to use, highly performant, portable, and reliable. Moreover, all of these libraries should adhere to a uniform physical structure, be devoid of gratuitous variation in rendering, and use consistent terminology throughout. By achieving such a high-level of consistency, performance, and reliability across all of the libraries at once, the local consistency within each individual library becomes truly exceptional. Moreover, even single-library projects that leverage such principles will derive substantial benefit.
There are many software methodologies appropriate for small- and medium-sized projects, but most simply do not scale to larger development efforts. In this talk we will explore problems associated with very large scale development, and the cohesive techniques we have found to address those problems culminating in a proven component-based methodology, refined through practical application at Bloomberg. The real-world application of this methodology – including three levels of aggregation, acyclic dependencies, nominal cohesion, fine-grained factoring, class categories, narrow contracts, and thorough component-level testing – will be demonstrated using the recently released open-source distribution of Bloomberg’s foundation libraries.
Auto - a necessary evil?presentation: 90 minutes
For example “auto i = 10;” declares a variable “i” of type “int”.
There were several motivations for providing a new meaning for this keyword. However, like many things, once a new feature is provided people will find creative things to do with it that may well go beyond the original expectations of the people who first made the proposal.
In this talk I will look at the times when you *must* use auto (which makes it 'necessary'.) I will then look at the interesting cases when you *might* use it - or perhaps abuse it (which makes it 'evil'). I also expect to cover some places when you may *not* use auto and a few 'gotchas' where you may not get what you expect!
I will try to identify the strengths and weaknesses of using auto so that you can make informed decisions in your own codebases about when auto should – and should not – be used.
The talk will be mostly focused on C++ although I may compare and contrast with similar facilities in other languages, such as 'var' in C#.
Bad test, good testworkshop/tutorial: 90 minutes
In this session, we re-examine the basics of a unit test. We will work through a number of examples with continuous input from attendees. Each example will start with a test of questionable quality, and we will work through the issues till we're happy that it's as good as we can get it.
Although this session is not specifically about the testability of software, this will necessarily be touched upon as we consider some test cases. Examples will be written in several common languages, but knowledge of all (or any) of them is not a pre-requisite.
Becoming a Better Programmertutorial/panel: 90 minutes
This entertaining session will help you to work out how.
With the help of a number of special guests, we will provide a series of practical, simple methods to become a better programmer. We'll gain some real insights from respected developers.
There will be plenty of hand-waving and jumping, a little philosophy, and some twists.
Be the best programmer you can!
C# is a doddletutorial: 90 minutes
C++11 features and real-world codetutorial: 90 minutes
In this session I'll look at a selection of C++11 language and library features that I've found of real practical benefit in application and library code, with examples of equivalent C++03 code.
The features covered will include the concurrency support (of course), lambdas, and “auto”, amongst a variety of others.
C++11 The Future is Herekeynote: 60 minutes
But most people are stuck in a 1970s or 1980s mindset, can we catch up to C++11? Worse, many people are stuck in a mess of “legacy code” creating a framework of constraints that discourage the use of 21 st century facilities.
My aim in this talk is not to enumerate the C++11 features or to go into great technical detail on a select feature. My aim is to show how the best practices for C++ design and programming is better supported by C++11 than by earlier versions. To do that, I discuss small code examples. I expect to use the concurrency library, standard containers, and chrono. I expect to use initializer lists, move semantics, variadic templates, lambda expressions, and type aliases. As usual, RAII (Resource Acquisition Is Initialization) will feature large.
C++11 User-defined Literals and Literal Typestutorial: 45 minutes
A second feature closely related to UDLs and compile-time evaluation are literal types in C++11. The biggest advantage of user-defined literal types is that they do not need to be POD, i.e., can have constructors, but still can be guaranteed to be initialized at compile time thus can be ROMable on embedded systems or will not become a synchronization nightmare in multi-threaded initialization. The talk will also show limitations of compile-time evaluation and will give a glimpse of what abilities to expect from future C++ standard versions with compile-time evaluation without the need for template-metaprogramming.
C++14 Early thoughtspresentation: 90 minutes
There will be an extensive Q&A on topics related to the evolution of C++.
C++ for Very Small Embedded Systemstutorial: 90 minutes
But there are still systems that have only a few kilo-bytes of memory for the program text and its data. For such systems many developers still believe that C++ doesn't work and you have to resort to assembler or maybe C.
This talk will show how C++ can be useful in such very small systems and programming techniques how to keep the overhead of C++ on such systems (over C) at essentially zero.
This talk is for embedded programmers who are tired to hear that C++ is not for them, or who actually believe this themselves.
C in the 21st century. Extensible languages with MPSpresentation: 90 minutes
http://emerginglangs.com/), however C is still the most used language and serves as the root for most of the “new” languages. Especially when it comes to the bare metal and real embedded development, there is nothing like C.
Compared with C++, C is admittedly less powerful / extensible (think of Domain Specific Languages DSL) but fiddling around with template meta programming (TMP) is really only for a small group of geeks. C++ has become a complex language (C++11 still is complex) and has lots of exceptions and side corners for originally useful language concepts (e.g. rvalue references and the issue with default generated move constructors/assignment operators, etc)
In C however we are painfully missing language concepts especially for developers in the embedded area. Because of its minimal language core there is no support for real encapsulation, safe types, operations with pre/post conditions, physical units and quantities, or common concepts in the embedded domain like tasks, messages or state-machines.
In this session I will show how we build modular languages which special emphasis for developing software for embedded systems. (The principle however is domain independent). We show how to extend the C Programming Language with the language concepts mentioned above. Embedded systems often support state-machines so there will be direct support for programs with states, triggers, events and actions as first level concepts. Also different flavours of syntax (e.g. textual, graphical and tabular) can even be mixed here. Expect a real usable physical units and quantities language with code completion and error messages in the IDE (not possible with TMP).
I will present the power of modular languages and show how to build languages extensions with the MPS Language Workbench MPS from Jetbrains. The mbeddr.com project (http://mbeddr.com) offers a set of C languages extensions for embedded software development. A case study with one of our real world sensors will demonstrate advantages and pros of the mbeddr solution.
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.
CATCH - A natural fit for automated testing in C, C++ and Objective-Ctutorial: 90 minutes
This presentation introduces you to the usage of CATCH, highlighting where it is different - and takes a look behind the scenes at how some of it is implemented (as many have been curious).
Cheating Decline: Acting now to let you program well for a really long timekeynote: 60 minutes
The talk will have two parts. The first will be summarized knowledge from successful old programmers and the people who work with them. The second will look at how, specifically, programmers decline, and it will contrast classical views about what programmers do with some of the claims of ecological (or embodied) cognitive science. If we consider ourselves animals acting in a world, rather than “brains in a vat” cogitating away, we can learn how to compensate for the inevitable.
Cleaning Code - Tools and Techniques for legacy restoration projectscase study: 90 minutes
This presentation will describe techniques for managing large legacy restoration projects. It will show how to create a technical roadmap and how to measure the value produced. It will show how to prioritize technical debt remediation tasks. It will show how various tools and techniques for visualizing different aspects of the development process. It will show how to put to use the psychology of change to keep developers and stakeholders motivated during the process.
Code as a crime scenetutorial: 45 minutes
We need strategies to identify design issues, a way to find potential suspects indicative of code smells, team productivity bottlenecks, and complexity. Where do you find such strategies if not within the field of criminal psychology? Inspired by modern offender profiling methods, we'll develop a metaphor for identifying weak spots in our code. Just like we want to hunt down offenders in the real world, we need to find and correct offending code in our own designs.
The session will look into test automation, software metrics and findings from different fields of psychology.
Coding Dojo Challenge-Refactoringdojo: 90 minutes
We'll be stepping into the Coding Dojo together, which is a safe place designed for learning, where it doesn’t matter if we make mistakes. In fact all the code will be thrown away afterwards. You should feel free to experiment, try out different refactoring approaches, and get feedback from your peers. The great thing about this Kata is that since the tests are very good and very quick to run, they will catch every little refactoring mistake you make. You should experience how programming is supposed to be - smooth, calm, and always minutes away from committable code. The last part of the session is the retrospective, when we discuss what we've learnt, and how we can apply our new skills in our daily production code.
The code kata we'll be looking at is “Tennis”, and the starting code is available on my github account, (see https://github.com/emilybache/Refactoring-Katas/Tennis). The code is available in various programming languages, including Java, C++, Python. You should bring a laptop with your favourite coding environment or IDE installed, or plan to pair with someone who has.
Concepts Lite-Constraining Templates with Predicatestutorial: 45 minutes
As a language feature, template constraints are minimal and uncomplicated, emphasizing correctness of template use rather than the correctness of template definitions. This means that they can be adopted incrementally and easily into an existing code base.
The talk will cover examples of how to use constraints with generic algorithms and data structures, member functions and constructors, overloading, class template specialization, and the definition of constraints themselves. I will also discuss my experiences using constraints in day-to-day programming, including some good ideas and some not-so-good.
An experimental compiler based on GCC-4.8 will also be made available to the audience.
Culture Hackingworkshop: 45 minutes
Death by dogma versus assembling agilepresentation: 90 minutes
During this challenging talk appreciated international speaker Sander Hoogendoorn, global agile thought leader at Capgemini, shows what happens with organizations and projects which are coached by well-willing consultants with little experience. Often this leads to very dogmatic applications of the more popular agile approaches, mostly Scrum and Kanban. This dogmatic thinking currently blocks the use of more elaborate techniques, tools and technology in agile projects, even when these would really improve projects. “No, you cannot do modeling in Scrum” and “Burn-down charts are mandatory” are two such simple real-life example statements. Due to this lack of experience and the growing dogmatism in the agile beliefs, more and more agile projects will fail.
But maybe even more important during this talk Sander will also show that there is no such thing as one-size-fits-all agile. Different organizations and different projects require different agile approaches. Sometimes lightweight agile, user stories, simple planning and estimation is just fine. But in many projects the way of working used should rather be built up from slightly more enterprise ready approaches, for example using Smart or FDD, smart use cases, standardized estimation, multiple distributed teams and on-line dashboards. During this talk Sander demonstrates how to assemble an agile approach that is specifically suitable for YOUR project, of course with many examples from real-life agile implementations.
Dynamic C++tutorial: 90 minutes
Given the above problem as well as both historical (ANSI C union and void*, MS COM Variant, boost::[variant, any, lexical_cast]) and recent (boost::type_erasure, Facebook folly::dynamic) development trends (including pending boost::any C++ standard proposal), it is obvious that there is a need for a way around the static nature of C++ language. There is also more than one solution to this problem; session will explore the internals of boost::[variant, any, type_erasure], folly::dynamic and Poco::Dynamic. Design, capabilities as well as pros and cons of each solution will be examined. Performance benchmark comparisons will be reviewed as well.
Type safety is an important feature of C++; type erasure is a necessary technique for modern software development. Session examines and compares existing solutions to these important concerns.
Effective GoF Patterns with C++11 and Boosttutorial: 90 minutes
Embedded Development, What's Changed in 30 years?tutorial: 90 minutes
Ephemeral Unit Tests Using Clangcase study : 90 minutes
Extreme Startupworkshop: 90 minutes
The aim of the workshop is to simulate software development in a quickly changing environment, where agile techniques should excel. How quickly can we iterate? What are the bottlenecks? Which techniques are most valuable? Do any fall by the wayside? Are any particular languages better or worse in this environment?
Each team needs at least one developer, but product managers can also actively take part in the simulation.
Teams need a laptop (or more than one) with development tools allowing them to build and run a small webapp in a language of their choice (e.g. Ruby, Java, Python, C#, nodejs, Scala etc etc).
As a practical session, this is a great chance to have some fun showing off your coding skills as well as your project management strategies, and hopefully think about the above questions.
This workshop has been run successfully at a number of conferences including: XPDays, XP2011, ROOTS 2012 and Agile on the Beach.
Fear and loathing on the agile trailworkshop/tutorial: 90 minutes
Using an interactive, choose-your-own-adventure style storyline, based on real-life experiences from many teams, this session explores common anti-patterns experienced by new and experienced agile teams. In each phase of the adventure we will learn how to recognise mis-application of an agile principle or practice, what forces might be causing this, and some interventions that can be helpful in overcoming them.
Since so many of the issues faced by teams are context dependent, we will use input from the attendees to frame the story throughout the session. Even though the resulting context may not apply directly to the attendee's teams, the storyline will provide a useful tool to take away and use to gain insights into specific agile environments.
From plans to capabilitiespresentation: 45 minutes
Functional Programming for the Dysfunctional Programmerpreconference tutorial: 360 minutes
During this tutorial you will solve lots of coding problems, demonstrating that FP can be thought of as a style of programming rather than a language feature. And you’ll see that by adopting techniques and idioms from FP you can make your code cleaner and safer no matter which language you use.
This will be an extremely practical session in the style of a dojo or code retreat. You will be programming many tasks throughout the day and so you will need a laptop with your text editor of choice. You will not need any experience of FP nor any theoretical background, but if you have either of those then bring them to share!
Generic Programming in C++: A modest exampletutorial: 90 minutes
In this session, I will take a request from the boost mailing list: “Why doesn’t boost have hex/unhex functions, I think they would be useful” and walk through the design and implementation of these algorithms for the Boost.Algorithm library.
Although the functions are simple, there are a surprising number of interesting design decisions that were made along the way – and I will explore them in this talk.
Generic programming design
Dealing with iterators (including the problems with output iterators)
Template metaprogramming (including enable_if)
Fit and polish of code.
Note: If you want a sense of the presentation, here is video (and slides) of an older version
Getting Legacy C/C++ under Testpresentation: 90 minutes
C++ has a rich set of libraries which support the creation of fake and mock objects (i. e., test doubles). The overwhelming part of them are based on subtype polymorphism by inheriting the test doubles from a common base class to be able to inject them as well as the real objects into the system under test (SUT). This has the known disadvantages of decreased run-time performance and the software engineering issues that come along with inheritance like tight coupling and fragility. Beside this, these libraries often lack an integration into an IDE.
We at the Institute for Software, are eager to improve this situation and address this with Mockator Pro, a new mock object library and a supporting Eclipse C++ Development Tooling (CDT) plug-in that assists the user in creating test doubles. Mockator Pro both supports C++03 and the new standard C++11.
Beside the mentioned subtype polymorphism - which is supported by a new „extract base class“ refactoring - Mockator Pro offers static polymorphism to inject the test double into the SUT via template parameters. The test doubles are realized as local classes, therefore located in the same function as the unit test code, leading to an increased locality that makes it easier to keep them in sync. A third form of mocking is the use of link seams which allow us to replace existing functions with our own test double functions without touching the SUT.
This talk shows how useful Mockator Pro can be for getting rid of fixed dependencies in your code base by extracting template parameters and base classes. You will see that Mockator Pro is able to generate code for test doubles that allows you to track if your SUT is properly using them. Our static code analysis checkers recognize missing member functions, constructors and operators in the injected test doubles and provide default implementations for them through Eclipse quick fixes.
Beside a practical session with many code examples we will also give an introduction into testing with mock objects in general and compare Mockator Pro to other well-known mock object libraries. Additionally, we will talk about the use of C++11 and its new features in our mock object library that allowed us to greatly reduce the need for preprocessor macros, therefore providing transparency and the chance to debug when problems arise.
Keywords: C++, mock object, Eclipse, static polymorphism, dependency injection
Git - Why should I care about the index?presentation: 90 minutes
What is the index and why does Git have it?
The index is a staging area for your next commit. It is also a “stat” cache which ensures that Git has the performance characteristics that it needs. The index is also the merge resolution area. The fact that the index supports these diverse purposes contributes to its conceptual complexity.
To dispel some of the confusion that surrounds the index we look at the internals, what is stored in the index and how it is stored.
We look at what operations read and update the index in normal usage. We also examine what commands we can use to deliberately affect the index and why we might want to perform them.
Growing C++ Software Guided by Testsexperience report: 90 minutes
The inspiration lasted, and in early 2012 Alan joined a team at Canonical where the right conditions existed to put these practices into effect. This talk follows a project developing a C++ systems component.
Every organisation is different and, in addition to the common learning curves for team members (TDD, C++, C++11, OO, problem and solution domains) they were also faced with geographical distribution across timezones. Fortunately, with a bit of intentional practice, the tools for remote working are, at last, up to the job.
The talk will cover the organisational, process, and technological challenges and the solutions adopted.
Gumption traps Reloadedworkshop: 90 minutes
Software developers, managers and coaches who would like to avoid gumption traps for themselves and their teams.
The purpose of the opening presentation is to introduce the topic and lead into group discussion. Participants are invited to share relevant stories with the session group, this leads into a brainstorming session on drawing out factors affecting motivation in software development.
The session participants will then be divided into smaller work groups and given a worksheet on influence charts. Each work group will select a story based on their own experience and work to create an influence chart that shows factors impacting motivation.
To wrap up, each work group will take a turn to present their chart and insights gained to the session group.
00:00 - 00:05 Introductions
00:05 - 00:20 Slide presentation on identification of gumption traps, suggestions for how to avoid them
00:20 - 00:25 Questions
00:25 - 00:40 Sharing Gumption trap stories
00:40 - 00:45 Divide session participants into work groups
00:45 - 01:15 Each group explores a story using influence charts (aka diagram of effects)
01:15 - 01:30 Each group presents what they learned to the session group
Hardware for Softies: physical computing with the Raspberry Pipreconference tutorial: 360 minutes
We'll start by writing a program that drives a bar LED display using the Pi's GPIO pins.
Then we'll look at using the i2C interface to get access to additional GPIO pins, and measure and control analogue voltages using an ADC/DAV converter chip.
Most robotics applications involve movement of some sort, and we'll experiment with controlling motors and servos from the Pi.
Finally we'll explore the Pi's SPI interface.
Health and Hygiene in the Modern Code Basepreconference tutorial: 360 minutes
How to Narrow Down What to Testtutorial: 45 minutes
Nowadays testing, especially writing automatic test cases, costs a lot. This looks like an extra expense in short time, but saves a lot of trouble in the long run. However, not every organisation can afford to spend expensive coding time on testing that considered as no real value to the customer.
The best way to do this is to be effective, so test those parts of the code which really need to be tested. In my presentation I'm going to share several methods that can be used to find areas which are worth testing so that organizations do not have to spend more effort on testing than what is absolutely necessary. These methods will be presented on java and ruby on rails examples.
How to program your way out of a paper bagtutorial: 90 minutes
Hybrid programmingtutorial: 90 minutes
Inspiring future generations with open hardware - the Raspberry Pikeynote: 60 minutes
The hope is to see it being used by kids all over the world to learn programming, but it also serves as an ideal platform for hobbyists to try out new ideas.
Eben Upton, Founder of the Raspberry Pi Foundation, will talk about the transition from large, high performance systems to cheap, low power and potentially disposable hardware.
But what does the future hold for these innovative and disruptive products? Will threats to openness result in complete closure of future hardware platforms?
Is eXtreme Programming still alive and kicking?case study: 45 minutes
I've worked as an independent consultant helping teams figure out how to apply Scrum in various context and seen some cool and crazy things done. In June 2012, I started work as a coach at Unruly Media, a company founded by some of the original team members at Connextra. Immediately before this, I also worked for Industrial Logic who built upon their own IndustrialXP method and re-evaluated many XP practices from a Lean perspective. Over the last year, I've found it really interesting to see how many old-school XP practices are still helping developers and where gaps remain (such as working with UX and Infra specialists). It's also been interesting to see how open our XP team is to “embracing change” and experimenting with ideas from Kanban and Scrum.
Come to this session if you have an interest in hearing about current state of XP and how it's been evolving.
Java 8 a new beginningpresentation: 90 minutes
Java is now often portrayed as boring, staid, a legacy technology. Yet the Java Platform based on the JVM is a vibrant arena: Scala, Groovy, JRuby, Clojure, Jython, Ceylon, Kotlin – a mix of static and dynamic languages pushing the use of the JVM to new places. Java has to compete with Scala, Ceylon and Kotlin in the “static language for the JVM” crown; the association of Java as the language for the JVM is long past. Can the changes to Java in Java 8, and later Java 9 and Java 10 (there is a road map all the way to Java 12), sideline Scala, Ceylon, and Kotlin, or is it already too late for Java?
What are the features of Java 8? Why are they just copies of what is in Scala (and possibly Ceylon and Kotlin)? Are Ceylon and Kotlin at all relevant to the JVM-based world? What is all the fuss about? Come to this session and join in answering some, all or none of these questions.
Lightning talkspresentation: 60 minutes
We will be putting the actual programme of talks together at the conference itself. If you are attending but not already speaking, but you still have something to say, this is the ideal opportunity to take part. Maybe you have some experience to share, an idea to pitch, or even want to ask the audience a question. Whatever it is, if it fits into five minutes, it could be one of our talks. Details on how to sign up will be announced at the event, or simply collar Ewan whenever you see him in the hallway.
Location, location, locationtutorial: 90 minutes
From finding the nearest pub in a smartphone app to analysing the spatial relationships of billions of GPS tracks, there are lots of tools, many free and open source, that can help you make sense of geospatial data quickly and easily. It has never been easier to integrate sophisticated location-based analysis into your application or business.
In this session we will learn about the key concepts behind geospatial data and analysis, including GPS, coordinate systems, projections, and different types of spatial relationships. We will discover the features of open source geospatial databases that let you query 2D and 3D data using SQL, GIS tools, and some of the online APIs that let you to add mapping, geocoding and more to your application.
To finish off, I'll show you how to build a web service that finds the nearest UK postcode to any latitude and longitude, performing spatial SQL queries using an open source database and data freely downloadable from the Ordnance Survey OpenData project.
Logic Programming and Test Data Generationlistecture: 45 minutes
Secundum: generating complex test data is a hard problem, in part because constraints (relationships) amongst bits of the data have to be obeyed. The sadly common result is fragile tests that know too much about the details of their data.
Ergo: I will explain logic programming by showing how it can be used to generate test data from minimal descriptions of what's needed.
Managing from the Mountaintoppresentation: 90 minutes
Measure and Manage Flow in Practicesession: 45 minutes
Measure and Manage Flow is the third of the core principles of Kanban. It means that the members of the organisation are supposed to measure their progress and use the gathered information to improve their way of working. The most famous measurement tool for Kanban is the Cumulative Flow Diagram, but there are other usable approaches out there.
During the last two years I tried out those different measurement approaches, and in my presentation I’m going to show you those which worked well for me. I’ll also cover how to manage your organisation by using the gathered data - e.g. how to use lead time for fine tuning the delivery process - and scientific methods to ensure that the changes are permanent and the organization moves forward.
Methodology a la cartetutorial/workshop: 90 minutes
Move, noexcept, and push_back() and how they relate to each othertutorial: 90 minutes
Organizational influence hackstutorial: 45 minutes
OTP, the Middleware for Concurrent Distributed Scalable Architecturespresentation: 90 minutes
In this talk, Francesco will introduce the building blocks that form OTP, the defacto middleware that ships with the Erlang/OTP distribution. He will cover OTP’s design principles, describing how they provide software engineering guidelines that enable developers to structure systems in a scalable and fault tolerant way, without the need to reinvent the wheel.
Talk objectives: Introduce a powerful framework which reduces errors and helps developers achieve robustness and fault tolerance without affecting time to market.
Target audience: Erlang beginners and engineers and architects implementing scalable, server side systems.
Parallelism in C++1ytutorial: 90 minutes
This talk will present some minor additions for concurrency support in C++14, as well as some more substantial proposals for C++17 targeting mainly real parallelism (and not just multi-threading) and generally asynchronous programming models currently discussed in the C++ standardization committee.
This talk is for programmers and designers who are interested in an overview of discussed concurrency additions in the next revisions of C++.
Pattern-Oriented Software Architecturepreconference tutorial: 360 minutes
This session will start off with basic pattern concepts and practices, with examples, and work through a number of more sophisticated ideas, such as the relationship between pattern-oriented thinking and incremental development, patterns and architectural styles, and how you can mine patterns in your own systems.
Real Architecture-Engineering or Pompous Bullshit?presentation: 90 minutes
We believe that most activity, going under the name architecture, is NOT real. Current Software architecture is no more real architecture than hackers are software engineers.
If we are just informally throwing out nice ideas, let us call ourselves Software Brainstormers. But if we are dealing with large scale, serious, and critical systems, then we need to stop using cabin-building methods and start using skyscraper designing methods. We need a serious architecture and engineering approach.
• defining architecture properly : even the standards are wrong
• what is bad architecture
• real architecture responsibilities who does what to whom
• the technical disciplines we need; quantification, estimation measurement of multiple qualities and costs
• architectural decomposition: a value basis
• software design, the same process, a different level
• the role of iterative feedback in verifying architecture
• The Architecture Manifesto: (advice for the revolution
Refactoring to Functionalworkshop: 90 minutes
At a previous XpDay, several of us found that we'd developed a similar approach to writing Java which includes a strong bias towards immutability and functional code within objects. The game changers have been a JVM that makes transient objects cheap, and Google nearly-lazy collections library. We've found that the resulting code style is easier to understand and less prone to certain kinds of bug. Working in this style, we've found that there are some common patterns for moving to a “functional-inside” approach to code.
In this workshop, I will present some techniques for moving from imperative to functional code, with worked exercises for the participants to join in.
Robust Software - Dotting the I's and Crossing the T'stutorial: 90 minutes
This session delves into those less glamorous non-functional requirements that crop up the moment you start talking to hard disks, networks, databases, etc. Unsurprisingly it will have a fair bit to say about detecting and recovering from errors; starting with ensuring that you generate them correctly in the first place. This will undoubtedly lead on to the aforementioned subject of testing systemic effects. Finally there will also be diversions into the realms of monitoring and configuration as we look into the operational side of the code once it’s running.
At the end you will hopefully have smiled at the misfortune of others (mostly me) and added a few more items to the ever growing list of “stuff I might have to think about when developing software”.
Ruby and Rails for n00bsworkshop: 90 minutes
Each step along the way will follow the same pattern:
explain the goal
formulate the goal as a test
see the test fail
implement the step
see the test work
refactor if necessary
release if the feature is finished
Aim: developers who never used ruby or rails come out with the basics of the ruby syntax and idioms, and can get started building a simple rails application while understanding each step of the way.
Server login considered harmful - introduction to devops practicestutorial/case study: 90 minutes
While doing this, we learnt that each time we logged in to our servers, we were building up technical debt for our configuration management. Hence 'Server login considered harmful'. We try to 'import software development;', use practices like continuous integration and TDD. However we have to keep ourselves honest: as long as we can't recreate a server completely from our scripts, we are not done. We will explain why we do this, and what obstacles we encountered. After that we will introduce Chef as a way to do 'infrastructure as code' and show how we work with it by doing some live coding. We will invite some participants to pair with us for the audience.
Come to this presentation to learn from our DevOps mistakes and successes, see if you can benefit from the tools we use, and if you also have experience, there is room to exchange ideas.
SFINAE Functionality Is Not Arcane Esotericatutorial: 90 minutes
Taking Scala into the Enterprisetechnical session: 90 minutes
Test driven development on the Raspberry Pitutorial: 90 minutes
This will be bits of presentation mixed with a prepared kata to show how we do it.
Doing test-driven development for embedded devices is possible. It has its' own set of constraints, such as:
limited availablity of hardware due to time or cost constraints
some hardware will not run your favourite programming language
hardware is slow and/or has a limited amount of memory available
real-time constraints on several parts of the software
you often have to combine multiple devices, each with their own hardware and software interfaces
Luckily Moore's law also applies to embedded development so we can increasingly use higher level languages, which make practices like test driven development and continuous integration feasible for embedded development as well. And with some creativity we can write end-to-end tests for the parts of our solution that defy unit testing.
In this presentation we will show how we developed a soft-drinks vending machine prototype using raspberry pi's, arduino, lego and various bits and pieces. See how we used test driven development and hexagonal architecture to keep our code clean and our minds sane.
topics: test driven development, hexagonal architecture, continuous integration, growing object oriented software guided by tests audience: developers, lead engineers
Description of the hands-on session to go with it:
Embedded TDD on the Rasbperry Pi hands-on On the one hand, 'embedded' becomes more and more software. On the other, software gets embedded in more and more things. With devices like the Raspberry Pi and Gumstix rolling your own becomes feasible. At least we can experiment with getting fast feedback cheaply. Test Driven Development (TDD) can drive your design and give fast feedback on the quality of your work. Doing this on an embedded device gives some additional challenges - it's often not so easy to talk to the device & get your software on it, while the choice of programming language is often limited (C anyone?).
Join this session to have some fun with TDD on a Raspberry Pi with a two line display and some buttons. Add a feature to our vending machine by writing some end-to-end tests and unit tests first.
If you're lucky, you can run your tests on the Raspberry Pi from our buildserver, but since like in the 'real world' 'the device' is not that often available… you'd better be lucky, or develop with discipline ;)
The Actor Model applied to the Raspberry Pi and the Embedded Domainpresentation: 45 minutes
This talk will demonstrate how, creating a layered architecture for hardware modules and partitioning up complex systems in smaller units, testing becomes much easier, runtime errors are contained, and the architecture becomes maintainable.
Talk objectives: Provide an overview of the embedded systems design methodologies and introduce Erlang Embedded, a new proposal to deal with the issues we face in today's complex embedded systems.
Target audience: Hardware and software engineers interested in designing the next generation of concurrent, distributed embedded systems.
The art of reviewing codetutorial: 45 minutes
It is also often an unpopular measure among developers and managers, for various reasons that have a lot to do with the time used to execute them and the fear that developers might have of getting critique on the code they created themselves. In this talk we first look at the advantages and disadvantages of using code reviews. We will then examine how to incorporate code reviews into existing processes. And we go into the fine art of giving and receiving code critiques: how much can be done in a code review, what types of critiques are useful to give, how to handle critiques that you don't agree with, and how to handle conflicts that might arise from this.
The bright side of exceptionspresentation: 90 minutes
Some ancient languages like C don't support exceptions at all. You need to indicate them with specific return values from functions. Languages with explicit support for exceptions (e.g. Java, C++ or Python) provide built-in facilities for handling them. The most traditional approach to this is the “try/catch/throw” system, whatever it may actually be called in your favourite language. As it turns out, this system suffers from limitations which affect its usability in complex situations. The two major problems are 1. the obligatory stack unwinding on error recovery and 2. a two-levels only separation of concerns (throwing / handling).
In this talk, we will demonstrate the benefits of using a system which does not suffer from these limitations. More precisely:
- the stack is not necessarily unwound on error recovery, which means that the full execution context at the time the error was signalled is still available,
- the separation of concerns is 3-fold: the code that signals an error (throw) is different from the code that handles the error (catch) which itself is different from the code that chooses how to handle the error (restart).
It turns out that an exception handling mechanism like this is able to handle more than just errors and in fact, even more than just exceptional events. In Lisp, this system is called the “condition” system. Conditions are the bright side of exceptions: not necessarily bad, not even necessarily exceptional. Conditions become an integral part of your programming paradigms toolkit. We will provide two examples of “condition-driven development”. The first one will show how to handle actual errors, only in a more expressive and cleaner fashion than with a regular try/catch/throw system. The second example will demonstrate the implementation of something completely unrelated to error handling: a user-level coroutine facility.
The Git Parabletutorial: 90 minutes
60 minutes + 30 mins Q&A
Learning and using Git commands is all well and good, but until you have a working understanding of how Git itself thinks and works, it will still feel like a strange beast with lots of sharp and pointy bits.
Based on Tom Preston-Werner's essay of the same name, this introductory Git talk will start from scratch - using simple concepts like a text editor and simple file system operations - to develop a simple and straightforward version control system that is very similar to Git. This gives you a mental model of how Git works, which will help you use Git more effectively and might even clear up some common misunderstandings if you come from centralized version control background.
The talk covers how Git does branching and merging in a distributed (and partially disconnected) environment, how Git allows you to rewrite your commit history to present a prettier set of changes to your peers, and also why the concept of a staging area is so useful in your day-to-day work. Finally, the talk explores some of the techniques that Git employs to become incredibly fast and space-efficient.
Git might still have some sharp and pointy bits, but after this talk you should be better equipped to understand how they can work to your advantage.
The talk is followed by a Q&A session, in which the speaker makes a futile attempt at answering any and all Git-related questions that might arise.
I have done this talk a couple of times already, and you can see my most recent “performance” here (web page is in Norwegian, but the talk/video is in English): http://ikt.tekna.no/git/
The slides are available here: https://github.com/jherland/git_parable
A history of a cachecase study: 90 minutes
The true cost of software bugs and what to do about ittutorial (with case-study elements): 90 minutes
We split the problem of debugging into three categories, and discuss tools and techniques to address each:
Preventing bugs in the first place: programming languages and techniques to reduce the number of bugs created.
Finding the bugs lurking in your software: static and dynamic analysis tools and testing techniques to uncover the bugs before your customers see them.
Panic debugging: tools and techniques to help find and fix the bugs found during development, testing, or (worst of all) reported by end users.
We show some of the more interesting work to address each of the above, including an overview of free (as in speech) software tools as well as proprietary ones. The talk focuses on practical use of tools and advice, and explicitly does not cover the more social aspects (methodologies etc). In particular we look at use of languages and libraries in order to prevent bugs, preventative tools such as Clokwork, CoVerity Prevent and Valgrind, advanced debuggers such as UndoDB and the tried and trusted, and much maligned, printf.
We also examine the economic and psychological barriers to preventing broader adoption of the tools and techniques we cover, and present the results of recent research quantifying the benefits that can be obtained by using more advanced tools and techniques to deal with bugs.
Transactional Memory for C++presentation: 90 minutes
https://sites.google.com/site/tmforcplusplus/ This proposal supports 2 types of transactions:
an isolated transaction that isolates from non-transactional code (as well as other transactions) through some kind of safety annotations
an ordinary transaction that allows communication with non-transactional code (but is isolated from other transactions)
We further show different techniques for supporting various levels of safety annotation, from fully static compiled time checking to some levels of dynamic checking to ease the burden for programmers.
It is the intention of the group to bring forward a fully worded proposal for Bristol 2013 as a Technical Specification. Now some of you have wondered if it is too early for TM. Let me say that HW is coming, with Intel's recent Haswell announcement, and IBM's BG/Q, and previously Sun's Rock. SW TM support has been here for quite some time with Intel's STM support of the 1.0 Draft, and most recently GCC C++ 4.7's nearly full support of Draft 1.1.
And if you think it is still too early, let me say that one of Hans Boehm's discovery was that locks are impractical for generic programming, because ordering of locks is generally not visible until instantiation. With the introduction of locking (and atomics) in C++11, this now becomes a difficult problem to avoid. Transactional memory is one way to solve the problem. It also helps for fine-grained locking on irregular data structures, and read-mostly structures.
In this talk, we will present the proposal for Standardization in C++, including supporting evidence of the usage experience, and performance data.
Finally, if you are still wondering is transactional memory fast enough? There are many different software transactional memory systems with different performance characteristics, so there is probably going to be one that fits your needs.
TM is coming in many different forms (HW, SW, hybrid systems, lock elision), and for C++ to remain in a good place with the many other languages that already support TM, this is the right time to be prepared with a sound proposal.
Unspecified and Undefinedtutorial: 90 minutes
In this talk we will study actual machine code generated by snippets of both legal and illegal C code. We will use these examples while studying and discussing parts of the ISO/IEC 9899 standard (the C standard).
Use the Sourcetutorial: 90 minutes
http://clang.llvm.org/> provides access to its internal data structures exposing all details of the source via a library interface. This library provides a basis for various tools like code-completion hints, static analysis, code transformations, etc. This presentation gives an introduction to create your own tool using C++ source.
Using data to understand how you develop softwareexperience report: 90 minutes
I'll also be asking the audience to share their experiences of trying to use data to improve what they're doing.
What the C++ Library Working Group did nextpresentation: 90 minutes
So what comes next?
The standard continues to evolve, and if anything the pace is accelerating The ISO working group has initiated, at the time this is written, 10 distinct study groups to investigate ways to move the language and library forward, and there is interest in adding more! What will the next generation of C++ libraries look like, and what are the most active topics of interest for likely extensions?
As the current chair of the Library Working Group, Alisdair Meredith is uniquely placed to talk about their recent accomplishments, current plans, and future directions.
Worse Is Better, for Better or for Worsekeynote: 60 minutes
Whether it is programming languages, operating systems or development practices, we find many examples of this in software development, some more provocative and surprising than others. In this talk we revisit the original premise and question, and look at examples that can still teach us something surprising and new.