accu2007 Sessions

Conference 2007


Tuesday 10 April 2007

Implementing Lean Software Development (Mary Poppendieck, Tom Poppendieck)

Tue 10:00, 360 mins

Practical approaches for applying lean principles to software development

As global competitiveness comes to the software development industry, the search is on for a better way to create first-class software rapidly, repeatedly, and reliably. Lean initiatives in manufacturing, logistics, and services have led to dramatic improvements in cost, quality and delivery time; they can do the same for software development.

Of the many methods that have arisen to improve software development, Lean is emerging as one that is grounded in decades of work understanding how to make processes better. Lean thinking focuses on giving customers what they want, when and where the want it, without a wasted motion or wasted minute.

This tutorial provides an introduction to applying lean principles such as Rapid Response, Constant Learning, Built-in Quality, Local Responsibility and Global Optimization to software development.

Hands-on Agile Development Workshop (Kevlin Henney)

Tue 10:00, 360 mins

Agile development processes are intended to help developers avoid the problems of analysis paralysis, big up-front design, rushed testing and changing requirements. They treat analysis and design as continuous activities that start early in development but continue throughout, rather than as segregated phases divorced from other development activities.

Development is dynamically planned as incremental and iterative. Coding and testing are considered together and from an early stage in development. In particular, incremental design, continuous testing and responsive refactoring make up the programmer-facing discipline of Test-Driven Development (TDD). The goal of this workshop is to offer attendees hands-on experience of many of the practices involved in the construction phase of a development lifecycle.

As its title suggests, this tutorial is actually a workshop! Attendees will learn about the development side of agile development by doing it. It is based on undertaking four rapid sprints of development, working on a clearly bounded and well-defined problem. The emphasis is on scope management, iteration planning, TDD, pair programming and other practices and principles drawn from agile approaches such as Extreme Programming, Scrum and Lean Software Development, with guidance and feedback both during and in between iterations. This promises to be a good learning experience and a good workout for any attendee!

Audience: Developers with at least basic C++ skills. Deep C++ knowledge and TDD experience are not a prerequisite.

Notes: At least 50% attendees will be required to bring a laptop, so bringing a laptop as default is considered to be the best option. Laptops will need to have a reasonably standard C++ compiler installed (so VC6 won't cut it) and an editor that is easily usable without years of training, no matter how brilliant it might otherwise be (so, the need to master meta keys or modes is out). Time management is important to the running of the workshop, so late arrivals may find that they miss out.

C++ Productivity (Hubert Matthews)

Tue 10:00, 360 mins

This tutorial is for C++ programmers who want to get more done. Mixing hands-on practical coding exercises with discussions and reflection, it covers a wide range of C++ idioms and techniques, use of the Standard Library and the STL, as well as scrutinising some conventional and received wisdom about C++ and object-oriented design. We will also discuss some of the self-imposed mental blocks that slow down development.


Wednesday 11 April 2007

The Software Development Pendulum: A Brief History (Mary Poppendieck) KEYNOTE {Notes}

Wed 09:30, 60 mins (University)

Mary Poppendieck has been involved in software development for over three decades, both as a programmer and as a manager. She will take us on a walk through the history of software development as she experienced it, tracing the pendulum of accepted practice as it swings from one extreme to the opposite extreme, and then back the other direction - never quite settling into the sweet spot in the middle. She will examine examples of truly excellent software development and discuss where they fit on the pendulum's path and point out the surprising lessons to be learned from these resounding success stories.

Coaching Software Development Teams (Michael Feathers)

Wed 11:00, 90 mins (University)

When we first get into software development, we concentrate on technical skill. We learn how to program, how to debug, and how to design effectively. If we are lucky, we work in an environment where most of that work isn't wasted effort. Most of us gradually realize that we are sensitively dependent on our team. The way that we interact with our coworkers, and they interact with each other, can make work productive and fun, or wasteful and hellish. In this tutorial, I'll outline techniques you can use to help software development teams overcome obstacles, gain confidence, and work well with their surrounding organization. You'll learn when to use them, and more importantly, when not to as you work with your coworkers to make your team more fun, effective, and humane.

Advocating Agility (Gail Ollis) {Notes}

Wed 11:00, 90 mins (Cherwell)

You have concluded that agile software development is the way to go. Now what? What happens when you try to communicate the big idea to your organisation? Will people 'get it' if they haven't read the literature, attended tutorials, spoken to the experts and given a lot of thought to how agility could help with the issues they face?

With such a wealth of convincing and enthusiastic material available on the what, how and why of agility it is easy to overlook the concerns that people may have. In this interactive session I will share my experiences of advocating agile practices to developers and managers. Delegates are invited to share their own experiences of preaching to the choir or facing a closed door. Forewarned is forearmed, so this session should benefit anyone going home full of conference-fuelled enthusiasm. The aim is for everyone to get some fresh ideas which will help them start or continue the process of bringing about change.

Semantic Programming (Ric Parkin) {Notes}

Wed 11:00, 90 mins (Blenheim)

    memset( &buffer, sizeof(buffer), 0 );
                                    

Compilers are very good at spotting syntax errors but cannot help with syntactically correct code that does the 'wrong' thing.

Starting with real world examples of such problems, we'll look at how strongly-typed languages provide a range of techniques - from the humble typedef to dimension-aware type systems, to RAII and 'smart' types enforcing behaviour - that encode meaning into the type system. These types can be considered as a domain specific language dialect that makes the application programmer more productive, with the compiler catching semantic errors and generating housekeeping code for you.

Java Performance Model (Angelika Langer) {Notes}

Wed 11:00, 90 mins (Charlbury)

In every programming language there is a notion of how much a language construct costs in terms of performance. This correlation between language construct and performance is called the performance model of the language. This talk is devoted to the performance model of Java.

Java was introduced as a "simple" programming language and consequently one would expect a simple performance model. The opposite is the truth. Complex and ambitious optimization techniques applied in the compiler and the runtime system improve an application's performance, but render an intuitive understanding of performance issues in Java close to impossible. Accordingly difficult is the development of high-performance Java software. In cases where the automatically applied optimizations do not suffice, the developer must cope with the complex Java performance model.

In this tutorial we explain the Java performance model and illustrate its complexities, using examples from our industrial experience. In this context we discuss strategies for detection and evaluation of information related to the performance model and the use of tools that support detection of performance impediments.

Testing Mobile .Net Applications (Steve Love) {Notes}

Wed 11:00, 90 mins (Wolvercote)

Case study describing how mobile applications for .Net Compact Framework v2.0 can be "Designed for Test", and some of the tools available which assist that.

A common difficulty experienced with mobile applications is that testing needs to be done on the device. This in turn takes a long time, and is difficult to perform, with the usual consequences of insufficient coverage, and long hours spent debugging. Tools exist to help in this effort, including device emulators and very clever debugging environments, but ultimately the responsibility for making an application testable lies with the developers.

This study looks at how testing mobile applications can be made easier by ensuring that most of that testing can be done off the device. The techniques for this are really no different to designing desktop applications for testability - separation of concerns, interface based design, Test Driven Development. .Net Compact Framework, being an almost true subset of the full .Net capabilities, makes it possible to write device-agnostic code which can be tested in the native development environment, using tools already familiar to .Net developers, such as NUnit. There are other tools which allow similar unit-level testing on the device for code which really is device specific, including NUnit CF Bridge, which this study will also look at.

A balanced Agile design approach (James O. Coplien) {Notes}

Wed 14:00, 90 mins (University)

Agile development usually talks in general about work queues and waves its hands about architectures all while singing the praise of user stories. How is a C++ programmer to reduce these to practice? This tutorial describes how to combine three techniques to achieve business objectives that go beyond the Agile tradition. The techniques are well known -- Use Cases, Domain Analysis, and CRC cards -- but they are combined in interesting and powerful ways to create a flexible, lightweight design method. The method helps projects create long-term business assets through lightweight front-loading of design. It reconciles user requirements with the architecture by separating role design from class design. The technique has been proven in many long-standing development projects ranging in size from a handful of people to teams comprising multiple departments. While the tutorial targets a C++ audience, the approach generalizes to Java development as well.

Reviewing the C++ toolbox (Alan Griffiths) {Notes}

Wed 14:00, 90 mins (Cherwell)

I've used C++ in a wide variety of projects over a long time and, in doing this, have had to learn different editors, build and deployment tools, unit and acceptance test frameworks and specialist libraries.

There are many more options in each category than I have time to explore myself, especially as most of them are "good enough" for the job in hand. Very few, however, seem to be ideal.

This workshop allows participants share experiences with other developers. It will begin with presenting a few of my experiences followed by a discussion of the categories of tools and what participants would like/expect from tools in each category.

Following this, groups will be formed to focus on specific categories of tool and to document the experiences of group members. The groups then present their findings for discussion in a plenary session.

Finally I'll summarise our findings.

Fingers in the air: a gentle introduction to software estimation (Giovanni Asproni)

Wed 14:00, 90 mins (Blenheim)

The process of estimating size, time, effort, etc., is fundamental for the success of every software project. Unfortunately, it is often the case that the stakeholders--including project managers, developers, and users--don't know how to do it properly (and also confuse estimates with commitments), and everybody ends up working against the clock to meet impossible targets, getting poor software late as a result. After a short introduction in which I'll present what can and should be estimated (e.g., time, size, effort, cost, etc.), and give an overview of some techniques, I'll focus on what is necessary to get started with some simple, but very effective techniques.

Finding the utility in a java.util.Iterator (Jez Higgins) {Further Information}

Wed 14:00, 90 mins (Charlbury)

    for(Iterator i = c.iterator(); i.hasNext(); )
    {
      Thing t = (Thing)t.next();
      ...
    }
                        

Is rolling through a for loop the best a java.util.Iterator can hope for in life? A poster-child of poor design, is running from one end of a container to the other all that Iterators are good for?

The C++ Standard Library also has a thing, lots of things, called iterators. They are part of the glue that combines containers with algorithms. The Library wouldn't be what it is without them.

The Java library gives us any number of containers, but almost nothing in the way of algorithms. Why not? Any why isn't anyone complaining? What impact has it had on the way other libraries for Java are written?

By examining some of the ways iterators and enumerators are used in other languages, we can widen the horizons of a Java Iterator. Using libraries like Jakarta Collections, Mango, and JGA as examples, this session aims to show how Iterators can be taken beyond simple for loops to become a significant and useful part of the Java toolbox.

So simple a child can program it, on a mobile phone (Development for Mobile Devices panel discussion)

Wed 14:00, 90 mins (Wolvercote)

Today, it is more likely than ever that a kid's first computer is going to be a mobile phone. Since the eighties, the Psion organisers from Series II through to Series 5mx all contained a "basic-like" programming language known as OPL, which supported end-users typing in and running programs on the device itself.

Alan Kay's work on Smalltalk was influenced by the ways children learn, and thus wanted something immediate and interactive for kids with little patience to learn programming with quickly. He also realised very early that progress in hardware would give him the platform he needed.

Mobile phones are rapidly becoming end-user programmable and in fact have far greater capabilities than the computers we learned to program on.

Can the advent of high level dynamic languages on mobiles, such as Python and Ruby, make programming on phones a child's play? How can the rest of us benefit and what can we do about it?"

C++ has no useful purpose (Russel Winder) {Notes} {Further Information}

Wed 16:00, 90 mins (Cherwell)

C++ was an interesting language in 1985. Now it is a liability.

In this talk I will show that languages like Groovy, Python and Ruby are the applications development languages of the future. These languages already have all the functionality that the C++ standard people are trying to cram into an already over-complicated language, and indeed have a lot more -- dynamism, reflection and portability to name three.

As for a proof, I will use a mini-`language showdown', interspersed with comparative analysis of language features to show that the best thing the C++ standards committee can do is to declare an end of life to C++.

Groovy, Python and Ruby are where programming is at. C++ has now joined Fortran as a dinosaur language preserved by the high performance computing community.

What about Java? It survives as the assembly language for Groovy programming.

Linting Software Architectures (Bernhard Merkle) {Notes}

Wed 16:00, 90 mins (Blenheim)

During Evolution of a software system, it becomes more and more difficult to understand the originally planned software architecture. Often a architectural degeneration happens because of various reasons during the development phases.

In this session we will be looking how to avoid such architectural decay and degeneration and how continuous monitoring can improve the situation. (and avoid architectural violations) In addition we will look at "refactoring in the large" and how refactoring can be simulated .

A new family of "lint like tools for software architectures" is currently emerging in the marketplace I will show some examples and how they scale and support you in real world projects.

Java Annotations in JDK 1.6 (Tony Barrett-Powell) {Notes}

Wed 16:00, 90 mins (Charlbury)

This session explores Java annotations (also known as metadata) what they are, how to write them and how to add them to the software development tool-chain.

Sun introduced annotations into JDK1.5 to support the growing trend to provide metadata to influence the processing of classes, methods and fields in development tools, deployment tools and run-time libraries. This was used to great effect as part of the simplification of EJB development.

In JDK 1.6 Sun have added the processing of annotations into the compiler superseding the separate annotation processing tool, making it easier to create user defined annotations and integrate them into the development tool-chain.

This session introduces the basics of annotations, the annotation processing API (integrated into the Java compiler) and how the annotation processing is implemented in the compiler. The session then explores the implementation of a simple annotation and the associated processor to be used during compilation. Finally, the limitations of the Sun annotation processing are discussed and alternatives presented that overcome these limitations.

Intended Audience

Anyone who is involved in development using Java who are interested in how annotations can help developers be more productive.

Recommendations for smartphone project success (David Wood) {Notes}

Wed 16:00, 90 mins (Wolvercote)

The session addresses the question, what are the most important things for a software engineering team to keep in mind, while working on a project to create smartphone software? Smartphones differ significantly from both "mini PCs" on the one hand, and "feature phones" on the other. These differences have important implications for software projects. The presenter has observed scores of smartphone software projects from close quarters, and many hundred such projects from a greater distance. These projects have varied from spectacular failure to glorious success. Over time, it has become clearer what are the principles dividing the successful and unsuccessful projects. Topics include: the economics of smartphone development projects, technical "ROPES", market awareness, simplicity vs complexity, principles of smartphone team-building, platformisation and re-use, integration and gate-keeping, the role of the project leader, strengths and weaknesses of tools, smartphone ecosystem dynamics, pros and cons of accelerating time to market, the smartphone open virtuous cycle, and process vs wisdom.


Thursday 12 April 2007

Improving Collaboration in Open Source Projects (Mark Shuttleworth) KEYNOTE {Notes}

Thu 09:30, 60 mins (University)

The pace of development on the free software stack has accelerated dramatically in the past ten years as the Internet has become ubiquitous and Linux has moved into the mainstream. However, there are still significant inefficiencies within the whole open source developer community. While we have tools for collaboration within projects, there remain barriers to entry that make collaboration between different projects very difficult. At Ubuntu, we face this problem constantly, since we package and deliver nearly 20,000 pieces of software, most of which have been written by other teams, and we need to be able to collaborate efficiently with all of them. This talk will look at the areas where collaboration can be improved and at some of the emerging solutions to the problem, especially those developed by the Ubuntu team.

Choose your Poison: Exceptions or Error Codes? (Andrei Alexandrescu) {Notes}

Thu 11:00, 90 mins (University)

Libraries and frameworks often must decide early on a strategy for error handling, which may not always be suitable for client code. This talk introduces a self-contained idiom that moves the error handling strategy from the called site to the caller site. Client code can rely on automatic error handling via exceptions, or handle errors locally in a error-code manner. An important fringe benefit is that exceptions always occur in client code, thus eliminating binary compatibility issues.

Towards Simple Code: A Workshop on the Value of Simplicity in Software (Peter Sommerlad, Giovanni Asproni, Kevlin Henney)

Thu 11:00, 90 mins (Cherwell)

The organizers observe that Simplicity is not valued high enough by many software people. For example, for many it is much cooler to employ the most modern complex technology in solving a problem than to strive for a simple, easy to understand, effective solution, obtaining as a result brittle, unmaintainable, and poorly performing software. We want to change that value system in our profession to push Simplicity as a value of software higher.

The goal of the workshop is to create a prototype of a kind of manifesto for software people to promote Simplicity: A Simple Code

Audience

developers designers, architects, managers

Notes:

Simple software often requires hard work (or thinking) and is rarely created the first time you tackle a problem. However, with Refactoring we are able to simplify software and that is what everybody should do.

Stop-the-Line Quality (Mary Poppendieck) {Notes}

Thu 11:00, 90 mins (Blenheim)

Every time software is implicated in a product failure, there are calls for the software development industry to police itself more aggressively and improve the so-called "abysmal" state of software quality. Usually this is translated into more aggressive testing at the end of software development. However, truly deep, enduring quality must be built into software, it cannot be created by after-the-fact testing. The company that routinely finds and fixes defects during verification does not have a process that is capable of producing world class software.

For decades, manufacturers have known that the secret to top quality is to devise ways to prevent defects from occurring, or, baring that, to detect them the moment they occur. When a defect is detected, world class manufacturers stop the line, find the root cause of the problem, and implement countermeasures immediately.

The answer to software quality does not lie in longer testing cycles after development is over. It lies in making quality assurance part of the specification process, creating testable designs, and having testers work side-by-side with developers to mistake-proof their work. It lies in creating effective test harnesses that are run as software is created so that defects become impossible or are discovered when only a small amount of code might be responsible. This makes it easy to find and remove the cause of defects, dramatically reducing debugging time, shrinking defect lists, and turning final verification into a mere formality.

Mary Poppendieck will discuss the processes and tools that exist today for creating Stop-the-Line Quality in your software development organization.

C# Uncommon Knowledge (Jon Jagger) {Notes}

Thu 11:00, 90 mins (Charlbury)

In this session Jon will present several examples of less commonly known parts of the C# language and its usage.

The knowledge revealed covers diverse areas of the language including enums, structs, properties, readonly modifiers, overloading, overriding, iteration, events, and threading."

Architecture, paradigms, idioms and weirdness of the C++ in your pocket! (John Pagonis) {Notes}

Thu 11:00, 90 mins (Wolvercote)

John promises to discuss the architectural paradigms, idioms and apparent weirdness of Symbian OS and Symbian OS C++ and how these came about - for those who really care to understand the 'whys' and 'hows' of this different platform.

This is an exposition of what happened and what was necessary in order to evolve a domain specific OS and framework with C++ when none else did. This talk presents the context, forces and constraints under which Symbian OS and its C++ framework came about in the last couple of decades, beginning from the early Psion days up to when the 100milionth Symbian OS device shipped.

In classic John tradition, the audience will need to be switching their brains between various domains such as the history of microcomputers and programming, to marketing and C++ and from embedded systems to software engineering in the large. John welcomes anyone who is interested in learning how the most successful C++ based operating system and C++ framework for small mobile computers came about (and more).

Format:

70 minutes or so of John talking (and he likes doing so) followed by heated discussions about C++ purity and pragmatic comments from the audience. All interruptions are welcome, as they help unblocking (hey it's a pattern:-).

Introduction to Component-Level Testing (John Lakos)

Thu 14:00, 90 mins (University)

Ensuring high reliability is achieved only by design -- fine-grain modular (component-based) design. Given a well-factored decomposition, it is possible to write highly effective, thorough tests at a cost that is *linear* in project size. This talk begins by exploring what it means to test. We then survey existing and novel test data selection methods that we find useful. Next we discuss the four basic techniques we use routinely to implement our test cases. Finally we discuss how to order test cases within a standalone driver program to exploit class functionality in order to boot-strap, and thereby streamline the testing process.

Pattern Connections (Kevlin Henney) {Notes}

Thu 14:00, 90 mins (Cherwell)

Patterns are often considered and presented in isolation or as part of a loosely themed catalogue. However, much of their power comes from connecting them together to describe whole systems or frameworks and how to build them.

With a focus on C++ and general OO design, this session considers the ways in which patterns may be combined, presenting a variety of concepts such as pattern compounds, pattern stories, pattern sequences and pattern languages. It presents and evolves examples to highlight the different kinds of relationship. The session encourages attendees to think beyond their conventional design pattern vocabulary, which is most likely anchored in the Gang-of-Four patterns. No mention will made of the Singleton pattern... OK, maybe one mention (but only one).

SOA in Practice, Part 1: Concepts and Technologies (Nico Josuttis) {Further Information}

Thu 14:00, 90 mins (Blenheim)

Service-Oriented Architecture (SOA) is getting mainstream. However, experience shows that there is a huge difference between expectations and promises on one hand and reality on the other hand.

In his talks, Nicolai Josuttis, will present several examples of what it means to introduce and live SOA in practice. As a team leader of the realization of a SOA at a world-wide mobile phone company, he knows about the difference of theory and concepts on one hand versus reality and practice on the other hand.

The talks present the essence of the newest book of Nicolai Josuttis, called "SOA in Practice", published by O'Reilly.

Part 1, "Concepts and Technologies" will concentrate on a more technical view of "SOA in Practice". This part includes topics such as terminology, architecture, service classifications, versioning, performance, and Web Services.

.NET Exception Handling - Traps and Pitfalls (Seb Rose) {Notes} {Further Information}

Thu 14:00, 90 mins (Charlbury)

We will examine the specifics of .NET exception handling concentrating on how this is different from exception handling in C++ (and to a lesser extent Java). We will examine some of the traps and pitfalls that you may encounter while

  • working in .NET
  • porting common idioms to .NET
  • moving from earlier versions of .NET to .NET 2
  • handling Win32 structured exceptions
  • invoking unmanaged code and remote components
This session will, necessarily, cover some of the basics of .NET exception handling, but is focussed on more advanced issues that are generally not covered in basic texts.

Untangling the Idioms: Eliminating the "accidental complexity" of native Symbian C++ (Jo Stichbury) {Notes}

Thu 14:00, 90 mins (Wolvercote)

With John Pagonis of Symbian having discussed the "weirdness" of Symbian OS C++, Jo Stichbury of the Nokia N-Gage Platform Developer Support team will explain how it is possible to write C++ code for rich content mobile games on Symbian OS - without getting tangled in its idioms. This talk will be of particular interest to those who've often thought about creating a mobile version of their favourite game but have never wanted to "deep dive" into the idiosyncrasies of Symbian OS. It will discuss the approach and techniques used by the N-Gage Platform to provide an environment for creating new games or porting those written for other C++ platforms. The talk will also provide insight into the world of games and games publishing, and discusses co-operative development across multiple timezones, organizations and mindsets (when the "jeans and trainers" meet the "suits").

Typical Pitfalls in Agile Software Development (Jutta Eckstein) {Notes}

Thu 16:00, 90 mins (Cherwell)

Nowadays agile methods are state-of-the-art. Many teams, projects and even organizations around the world are using Scrum, XP, Crystal Methodologies, or other known or self-made agile methods. However, not every project is succeeding using agility.

If you're looking behind the scenery, you will find out that although the agile practices like pair programming or test-driven development and the like are used properly, the agile value system is still not implemented. This is due to the fact that the practices can support agility but they can not establish agility.

This leads to an expectation mismatch regarding acceptance and success of agile development, because the achievements can't keep up with the expectations people have about agility.

In this session, Jutta wants to illustrate the typical pitfalls teams trapping into when following an agile approach as well as present some recommendations how to avoid those pitfalls. Thus, with her experience in helping projects all over Europe to establish the agile value system, Jutta will point out what to look out for when applying agility.

SOA in Practice, Part 2: Processes and Governance (Nico Josuttis) {Further Information}

Thu 16:00, 90 mins (Blenheim)

Service-Oriented Architecture (SOA) is getting mainstream. However, experience shows that there is a huge difference between expectations and promises on one hand and reality on the other hand.

In his talks, Nicolai Josuttis, will present several examples of what it means to introduce and live SOA in practice. As a team leader of the realization of a SOA at a world-wide mobile phone company, he knows about the difference of theory and concepts on one hand versus reality and practice on the other hand.

The talks present the essence of the newest book of Nicolai Josuttis, called "SOA in Practice", published by O'Reilly.

Part 2, "Processes and Governance" will discuss the non-technical aspects of SOA, which are even more important for a successful realization of SOA. This part includes topics such as business process modelling, service lifecycles, model-driven service development, and establishing SOA.

Test Driven Development with C# and NUnit (Richard Howells)

Thu 16:00, 90 mins (Charlbury)

This session explains how to apply automated unit testing to .Net code written in C#. We will use the open source NUnit tool, to provide software help in framing test cases, running tests and reporting results.

We will extend the idea of automated testing to consider how writing test code in advance of implementation code informs the coding process and allows the detailed design of the code to evolve as the code is produced.

This will be an interactive session and the audience will participate in code development using TDD.

Supporting Many Mobile Platforms: Making Your Killer App Dominate the Mobile World (Charles Weir) {Notes}

Thu 16:00, 90 mins (Wolvercote)

One of the biggest practical issues for mobile software development is the range of platforms to be supported: Symbian have several; Microsoft have more, and each have multiple flavours. The team at Penrillian have made a successful business of porting software between platforms. In this talk, Charles Weir shares their secrets:

  • The three key developer techniques for a porting project
  • Portable architectures - for different sets of platforms
  • The two worst mistakes to avoid when migrating code

Grumpy Old Programmers - The Ultimate IT Chat (Nico Josuttis) KEYNOTE

Thu 18:00, 60 mins (University)

Bouyed by the success of past years, Nicolai Josuttis gathers another extraordinary group of representatives of our IT business to talk about the most important, thought-provoking, and funniest IT headlines and tendencies of the past year.

Lean back and enjoy being a fly on the wall when a carefully selected (then press-ganged) group of participants chat in a pub-like atmosphere.

(Panellists to be announced)


Friday 13 April 2007

This Software Stuff (Pete Goodliffe) KEYNOTE {Notes}

Fri 09:30, 60 mins (University)

In this talk Pete will look at what software is, what is should be, how we write it, and how we can write it better. He'll also investigate custard and spaghetti.

The Appliance of Science: Things in Computer Science that every practitioner should know (Andrei Alexandrescu) {Notes}

Fri 11:00, 90 mins (University)

Practitioners must put in so much effort to stay abreast on technology, they sometimes forget useful results from computer science. Inspired by an idea of Scott Meyers, this talk gives the most important bits of research knowledge with direct practical applications, yet are not obvious, old, or new enough to have yet propagated from the academia to the industry.

Global, Yet Agile, Software Development (Jutta Eckstein) {Notes}

Fri 11:00, 90 mins (Cherwell)

There are not many projects left that are made at home without outsourcing, off- or nearshoring. Thus, global software development seems to be a fact in state-of-the-art software development. On the other hand more and more projects discover the success factor of agile software development: not only since the Standish Group is recommending this approach.

Although agile software development requests - among other things - an emphasis on face-to-face communication, several projects have tried meanwhile to combine global with agile software development.

In this session Jutta wants to provide an opportunity to share experiences in following an agile approach in a global development environment: What are the possibilities to overcome the challenges global software development provides, and what are the success factors for implementing an agile software development process within such constraints?

In this talk, Jutta will report from her experiences in bringing these two trends together and which practices help and which hinder the success of a project. Her own experiences are mainly based on large global agile projects in embedded and commercial software development.

Generative C++ in the Large: Applied Metaprogramming and Other Generative Idioms (Schalk Cronje)

Fri 11:00, 90 mins (Blenheim)

Generative programming offers a powerful approach to the manufacturing of software and non-software artefacts in heterogeneous software environments. To effectively apply the generative paradigm to C++ requires a good understanding of techniques such as template metaprogramming and generic programming. For many people the use of metaprogramming seems to be a distant dark art, perceived to be practiced by only a few elite programmers. This session intends to break down some of those barriers. As generative techniques can introduce a large amount of types part of the session will show how easy it is to manipulate type lists. Attendees will also be shown how to tie run-time loading of data into to predefined generated compile-time classes and the application of type-erasure and type-hiding.

Components from the Boost C++ libraries, including its powerful metaprogramming library, will be utilised in the session, distilling usage down to practical examples of building software components.

Audience:

C++ users with an understanding of templates. Understanding of metaprogramming is not a requirement. Attendees should feel free to ask questions about metaprogramming in the session.

PAAJSFDCICOP: Python And Asynchronous Javascript for Distributed Computation In Combinatorial Optimization Problems (Jan-Klaas Kollhof, Ed Sykes) {Notes}

Fri 11:00, 90 mins (Charlbury)

A case study into the suitability of asynchronous javascript and python for distributed solutions to combinatorial optimisation problems. We will present a tutorial in biologically inspired swarm intelligence followed by our experience of building a type of swarm intelligence based upon the behaviour of ants. This will include the way that we created the swarm intelligence with an explanation of the key functionality that enabled intelligence to be distributed across multiple machines. We will give a demonstration of the distributed intelligence working as well as an explanation of key pieces of technology.

Anticipated Languages / Technologies / libraries used:

  • Python
  • Javascript
  • JSOLait
  • AJAX
  • Numpy

It will be a balanced mix of humour and valuable information...

An Outline of C++0x [Future of C++ track] (Bjarne Stroustrup) {Notes}

Fri 11:00, 60 mins (Wolvercote)

This talk will give an overview of what we hope to deliver as a final Standard in 2009.

Generalizing Constant Expressions in C++ [Future of C++ track] (Jens Maurer) {Notes}

Fri 12:00, 30 mins (Wolvercote)

C++ uses constant expressions (i.e. expressions that are evaluated at compile time) for a number of purposes such as array bounds and case labels. However, current C++ exposes a number of limitations and surprises when considering which expressions can be evaluated at compile-time. This talk presents the C++ standardization committee's efforts in providing a more general and uniform compile-time evaluation facility that fully supports enumerations and (sufficiently simple) classes. Synopsis: The C++ threading model is a work in progress. This talk will present the current model, which includes a memory model, primitive atomics, dynamic initialization, thread creation, synchronization, and thread-local storage.

CUTE: C++ Unit Testing Easier (Peter Sommerlad)

Fri 14:00, 90 mins (University)

Writing unit tests for your code is a must today. Triggered by Kevlin Henney's simpler java unit testing framework JUTLAND, Peter tried to create an easier-to-use CPPUnit replacement. The design of CPPUnit comes from a time where neither C++ was standardized or Boost (or std::tr1 resp.) was available. As a framework, using CPPUnit for simple tests requires a lot of overhead and understanding of its inner workings. This lifts the threshold for unit testing unnecessary. That's the reason for CUTE.

The session will present CUTE, how it is used and how it is designed. For the experienced designer CUTE's design holds some interesting aspects, since it leverages features available in std::tr1 and demonstrates design patterns applied using templates instead of classical OO inheritance.

If possible, the audience will get the ability to exercise writing unit tests with CUTE and/or extend CUTE during the session.

Open Architecture vs Open Source in Defence Systems (Peter Hammond) {Notes}

Fri 14:00, 45 mins (Cherwell)

Defence software systems have traditionally been largely proprietary, closed source arrangements, where the source code and intellectual property remains with the supplier. Following the recent trend to COTS hardware, and the rise of open source software in the commercial sector, the government is keen to pursue open source solutions for defence contracts, seeing this as a route to improved reuse and extensibility, with the commercial advantages of not being locked in to a single source contractor. However, there are a number of obstructions to the provision of defence systems under open source licences. An alternative approach is to use an Open System architecture, where the system is broken down into replaceable components with well-defined interfaces and behaviour. This approach brings a different set of costs and benefits for both customer and supplier. If the project is to be a success for all parties, each approach must be understood and considered. The two approaches will be compared and contrasted in this presentation, supported by reference to recent projects.

Exposing problems / Creating awareness (Allan Kelly) {Notes}

Fri 14:00, 90 mins (Blenheim)

The problem we face is not knowing what to do, or how to do it; we know how to write C++, Java and Python, we know how to do Extreme Programming, SCRUM and Waterfall. The problem we face is changing our organizations to do things better.

The first step in changing things is to create awareness of need for change: people don't want to change for the sake of changing so you need to make them aware of what you are trying to achieve. This session will look at how we can go about creating awareness of problems and how we can use this awareness to create change in our organizations and improve our learning.

A Journey to a New Text Templating System (Chris Withers) {Notes}

Fri 14:00, 45 mins (Charlbury)

Most programmers, and certainly all who build any kind of web application, will have been faced with the task of generating textual output based on a template. To this end, many different systems and languages have evolved to cater purely for this need.

This session will take a look at a few of the examples I've bumped into in the past and the journey which lead me to my own take on text generation. Twiddler was born from this and I'll give an introduction to it along with some examples and a challenge to come up with something that's awkward to do in Twiddler!

Support for Numerical Programming in C++ [Future of C++ track] (Walter Brown)

Fri 14:00, 45 mins (Wolvercote)

This talk will discuss new C++ language and library features that improve the utility of C++ to members of the numerical computing community. These features include new C++0X and TR1 numerical library components, related C99 imports, and core language improvements leading to enhanced numerical capabilities and performance. We will also share our vision for the future of C++ in numerical computing.

Continuous integration: what it is and why you should use it (Ivan Moore)

Fri 14:45, 45 mins (Cherwell)

Continuous integration is not a new concept, but is nevertheless not particularly widespread, especially outside of the Java community. This means that there are many teams that don't use continuous integration that would benefit from its use. This tutorial introduces continuous integration, what it is and what it's benefits are, including a short practical demonstration.

Continuous integration is the practice of frequently integrating and checking in code, using an automated build that includes some level of testing to indicate whether each integration is successful or not. At the most basic level, this can be that the code compiles. At the other end of the spectrum it might involve automatically deploying the code into a production-like environment and running automated acceptance tests, load tests etc to check that the application works correctly.

Continuous integration is frequently associated with the use of a continuous integration server. This tutorial will demonstrate the use of a simple continuous integration server and explain some of the benefits and pitfalls of using one.

Builders:How MOPs Make Life Easy (Russel Winder) {Notes} {Further Information}

Fri 14:45, 45 mins (Charlbury)

Dynamic programming languages are now the applications programming languages of choice. However, many people do not feel safe without strong static type checking, and feel that meta-object protocols (MOPs) are "the spawn of the devil". The principle aim of this talk is to disabuse people of this notion.

In this talk, I aim to show that languages with MOPs can actually do things that are constructively useful and not just "toys for the dynamic programmer". In particular, I am going to focus on the concept of builders. Builders are ways of using MOPs to create internal domain specific languages that make creating hierarchical systems very easy indeed. The two applications areas that will be considered are graphical user interfaces and XML processing. The main language for examples will be Groovy (a dynamic programming language working on the JVM and symbiotic with Java), though some Ruby (or JRuby) and possibly some Python code may creep in to show that builders are a general dynamic language concept, not just one specific to a particular language.

The overall intention is to educate people using dynamic languages and to make people still using C++ extremely jealous.

C++0x Initilaisation: Lists and a Uniform Syntax [Future of C++ track] (Bjarne Stroustrup) {Notes}

Fri 14:45, 45 mins (Wolvercote)

Getting initialization right is an important part of programming. Over the years, this has led to a mess of language facilities and techniques. This talk describes how C++0x (most likely) will address two issues: how to get a uniform syntax and semantics for all initialization and how to allow initialization by general lists. Obviously, people will want the solution to be really simple and completely compatible. As ever, the resolution is to be almost completely compatible and almost simple.

This talk will describe sequence constructors, homogeneous and heterogeneous initializer lists, and (as far as time allows) fit generalized constant expressions, prevention of narrowing conversions, and variadic templates into this picture.

Experience Scrum (Rachel Davies, Giovanni Asproni, Duncan Pierce)

Fri 16:00, 90 mins (University)

Scrum is one of the leading agile software development methods. This session will give attendees a unique opportunity to experience agile practices first hand in a non-technical environment. Attendees will be introduced to Scrum concepts and then practice using them in a simulated Sprint. The session will be of interest to software delivery professionals, involved in the development and delivery of business critical systems, who are interested in learning more about agile methods and how they can support rapidly changing business needs.

Network Programming (Alan Lenton)

Fri 16:00, 90 mins (Cherwell)

While a lot of network programming is web based and done via HTTP and high level libraries, there are still many applications that require their own custom built communications.

This session will look at how to design and build robust TCP/IP communications into your application, and also how to implement your own, higher level, protocols on top of TCP/IP.

auto_value: Transfer Semantics For Value Types (Richard Harris) {Notes}

Fri 16:00, 90 mins (Blenheim)

The problem of eliminating unnecessary copies is one that many programmers have addressed at one time or another. This beginner/intermediate session proposes an alternative to one of the most common techniques, copy on write. We'll begin with a discussion of smart pointers, and why we need more than one type of them. We'll then look at the relationship between smart pointers and the performance characteristics of some simple string implementations, including one that supports copy on write. I'll suggest that a different choice of smart pointer better captures our intent, and show that what we were trying to do doesn't achieve half as much as we thought it would.

Finally, I hope to show that whilst the problem we set out to solve turns out to be a bit of a non-issue, this technique has a side effect that can be exploited to dramatically improve the performance of some complex operations.

Behaviour-Driven Development with Ruby (Dan North)

Fri 16:00, 90 mins (Charlbury)

Behaviour-driven development, or BDD, is an evolution in agile software delivery, with its roots in test-driven development, mock objects, domain-driven design and acceptance test-driven planning.

This session introduces the principles behind BDD and demonstrates the end-to-end process in Ruby using the popular rspec framework in conjunction with rbehave, a BDD acceptance testing framework.

C++ Threads [Future of C++ track] (Lawrence Crowl)

Fri 16:00, 60 mins (Wolvercote)

The C++ threading model is a work in progress. This talk will present the current model, which includes a memory model, primitive atomics, dynamic initialization, thread creation, synchronization, and thread-local storage.

Standard Library report [Future of C++ track] (Alisdair Meredith) {Notes}

Fri 17:00, 30 mins (Wolvercote)

How has the C++ Standard Library evolved to meet the challenges of the new language? What new facilities will be available, and are any going away?! Should the library updates change the way we write code? This session will run a high speed tour of the updated library, including the additional components from TR1. It will look at how the new language features might change the library. While you will not learn to write concepts or rvalue references, you should see the benefit they will bring.


Saturday 14 April 2007

Towards a C++ Memory Model (Hans Boehm) KEYNOTE {Notes}

Sat 09:30, 60 mins (University)

Many C and C++ programs use threads interfaces such as the pthreads API, either for program structuring, or to take advantage of multiprocessors. Although the pthreads specification gives fairly precise rules for accessing shared variables in this environment, it turns out that these are poorly understood by most programmers. Even when they are correctly understood, they are not quite sufficient to ensure reliability of multithreaded programs. These problems are known to generate occasional very puzzling failures in practice. They also make it even harder to teach programmers how to write multithreaded programs, a subject that is certainly already difficult enough.

I will review what the rules are and explain when and why they are insufficient. I will give an overview of the ongoing effort (with Doug Lea, Bill Pugh, Peter Dimov, Clark Nelson, Herb Sutter, others, and, at least so far, the strong support of the C++ standards committee) to extend the C++ language specification to address these issues. I will briefly explain why the issues seem to be inherently different from languages such as Java and C#.

Although much of this is still a subject of active discussion, I will present highlights of the current proposal. Even the uncontroversial aspects of this proposal will unavoidably have significant impact on both C++ compilers and multithreaded C++ programming practice.

Making New Friends (Dan Saks)

Sat 11:00, 90 mins (Cherwell)

A friend of a class is a function or class that is not a member of that class, but which nonetheless has access to all members of that class. The convential wisdom is that granting friendship increases coupling and therefore is something you do should sparingly. The lecture introduces a new reason for using friend function declarations in class templates that's not about granting access to non-public members. Rather, it's about using making a template as a factory for "making" new friends. Along the way, this session explains various subtleties about overload resolution, template instantiation, and name lookup for friend functions.

ICE (Tim Penhey, Giovanni Asproni)

Sat 11:00, 90 mins (Cherwell)

This is an interactive session/workshop where the participants will have the opportunity of learning some basic concepts about distributed systems such as dynamic discovery, multi language interaction, multi-threading, servers having multiple interfaces, etc., by writing a distributed application in the language they prefer among C++, Java, C#, Python, or, god forbid, VB!

In fact, the session will be in the format of a game in which the participants will have to write their own robots which will fight against each other in a battlefield--a server application written by the presenters (along the lines of the old c-robots idea - but extended for the distributed component world).

We'll make use of ICE (www.zeroc.com), a middleware technology--available under the GNU license for non-commercial software--which supports several mainstream languages(C++, Java, C#, Python, VB, and PHP).

Better Bug Hunting: Ways to improve finding and fixing bugs in software (Roger Orr) {Notes}

Sat 11:00, 90 mins (Blenheim)

We programmers spend a lot of time dealing with bugs - whether our own or other people's. Unfortunately there seems to be comparatively little investment in improving the techniques most programmers use to find and fix bugs, with the result that much bug hunting is frustrating, haphazard, inefficient, and resource intensive.

In my experience few developers apply consistent strategies to debugging and their ability to find bugs often lags behind their skill in other parts of programming.

In this presentation I will look at the activity of bug hunting and give some principles and strategies for making this more effective and less of a 'black art'.

The aim is to help you reduce the amount of time and effort it takes to find and fix problems in your programs; whether these are found during development or in live running. I hope it will also help you to enjoy debugging rather than fearing it.

The intended audience is any programmer who has some experience of hunting for bugs and wants to improve for the future. The examples shown will be mostly in C++ or Java but detailed knowledge of these languages will not be assumed; I intend to focus more on the general principles of debugging than on language or platform specific techniques.

Renga: Conceptual Integrity and Collective Code Ownership (Nat Pryce, Steve Freeman)

Sat 11:00, 90 mins (Charlbury)

"I will contend that conceptual integrity is the most important consideration in system design. It is better to have a system omit certain anomalous features and improvements, but to reflect one set of design ideas, than to have one that contains many good but independent and uncoordinated ideas." - Fred Brooks

A programming team that uses collective code ownership must collaborate in different ways than one in which modules are owned by individual programmers and design decisions are made hierarchically. All programmers in the group must find and follow a common programming style rather than follow their individual preferences, but that common programming style must emerge from their individual preferences rather than be dictated from above.

Programming style involves a great deal more than coding conventions. To be easy to understand, and therefore easy to change, a program needs "conceptual integrity", a feeling that all parts of the system are in harmony. Conceptual integrity of software, like that of poetry, relates to a consistent use of writing style, language, vocabulary and idiom. Local variations in style can have a disastrous effect on the conceptual integrity of the software as a whole and therefore on the team's ability to understand, correct, grow and adapt the software to new requirements.

Unfortunately, the only way to get a feeling of how programming style can affect conceptual integrity, and the effects that poor conceptual integrity can have, is to experience and compare projects in which conceptual integrity has deteriorated and those in which it has remained under control. That's a slow and expensive way to learn! This tutorial provides a similar learning experience through simulation and reflection.

Concepts: An Introduction to Concepts in C++0x [Future of C++ track] (Doug Gregor)

Sat 11:00, 90 mins (Wolvercote)

Concepts are a major addition to C++0x that make templates more robust, more powerful, and easier to write and use. At their most basic level, concepts provide a type system for templates. Using concepts, the C++ compiler is able to detect errors in the definition and use of templates before they are instantiated. One immediately obvious benefit of this separate type-checking capability is a dramatic improvement in error messages resulting from improper use of templates. Look a little deeper and we find that concepts support an entirely new programming paradigm, Generic Programming, enabling the construction of a new breed of generic libraries that provide better extensibility, composability, and usability than what is possible with today's C++.

This tutorial will teach concepts from the ground up. We will begin with an overview of the new features introduced by concepts and how they will benefit C++ programmers. Then, we'll dive right into concepts, building the core components of the C++ Standard (Template) Library. We will see how these core components are more robust and versatile than the equivalent components in today's C++. From there, we will explore some of the more advanced features of concepts.

Machine Architecture (Things Your Programming Language Never Told You) (Herb Sutter) {Notes}

Sat 14:00, 90 mins (University)

High-level languages insulate the programmer from the machine. That's a wonderful thing -- except when it obscures the answers to the fundamental questions of "What does the program do?" and "How much does it cost?"

The C++ programmer is less insulated than most, and still we find that programmers are consistently surprised at what simple code actually does and how expensive it can be -- not because of any complexity of C++ the language, but because of being unaware of the complexity of the machine on which the program actually runs.

This talk examples the "real meanings" and "true costs" of the code we write and run especially on commodity and server systems, by delving into the performance effects of bandwidth vs. latency limitations, the ever-deepening memory hierarchy, the changing costs arising from the hardware concurrency explosion, memory model effects all the way from the compiler to the CPU to the chipset to the cache, and more -- and what you can do about them.

The other 99 percent (Phil Nash)

Sat 14:00, 90 mins (Blenheim)

If we only use 1% of the power of our brains, what's happening with the other 99%? And can we tap into it to help us write better software more effectively?

Rather than being concerned with particular technologies or programming techniques, this presentation looks at how to improve what's at the core - the programmer, as well as their relationships with others.

While basic programming or problem-solving abilities are important, the way we orchestrate these abilities and our interactions with each other as part of an organisation, as well as customers, is also important - sometimes even more important! We'll look at a number of techniques and approaches that we can use to make effective use of our talents in a software development environment. We will look at such topics as: solving problems by running mental background tasks, improving team communication, accessing mental states (such as "focus" or "creative"), optimising our (physical) environment, the effect of health and fitness, and even code layout suggestions!

Performance Tuning (Klaus Marquardt)

Sat 14:00, 90 mins (Charlbury)

Performance tuning is an art that needs to be applied in virtually every project, often multiple times. This session combines an exploration of different approaches, and a rating of their efficiency based on project experiences.

An Introduction to the Rvalue Reference in C++0x [Future of C++ track] (Howard Hinnant) {Notes}

Sat 14:00, 45 mins (Wolvercote)

Rvalue reference is tiny addition to the C++ language which will have a large impact on the way you design your C++ classes and algorithms. It will free you to use standard library components in a much more flexible manner, and without having to worry about the cost of copying huge objects around.

Have you ever passed a large container by reference to a function as an "output parameter" when what you really wanted to do was have the function return the container by value? Sure, who hasn't. This session will teach you how and why C++0X will make it guaranteed- efficient to return standard containers by value from functions. Learn how to adapt your own heavy weight classes so that they too can always be returned from functions efficiently.

Have you ever put a non-copyable type on the heap, just for the purpose of being able to pass it among different scopes? Perhaps you wanted to pass it into a function, return it from a function, or put it into a container. Such practice is now a thing of the past. As an example, the standard (non-copyable) stream types are now movable. They can be put directly into containers, and returned from functions. This tutorial will explain how that is now possible so that you can do the same with your own non-copyable types.

Have you ever wanted to put auto_ptr into a vector, but had to compromise by using shared_ptr instead? This tutorial introduces unique_ptr, which in a nutshell is an "auto_ptr that works". It has the same overhead and semantics as auto_ptr, but is safe to put into containers.

Have you ever needed to forward a generic argument, either lvalue or rvalue, without changing its cv-qualification? Or equivalently, have you ever been frustrated that you can't pass rvalue (temporary) arguments to boost::bind functionals? No longer.

All of this and more simply represent applications of the rvalue reference. Learn the few simple characteristics of the rvalue reference and you will see how all of the above is now possible, not only for the standard library, but for your own code as well. Get a head start on C++0x. By doing so you may well find your own innovative uses of this new tool.

C++ Modules [Future of C++ track] (David Vandevoorde)

Sat 14:45, 45 mins (Wolvercote)

Modules have a potential for radically changing the way we program in C++. In this presentation I will deal with what we are proposing and why we believe modules will become important to C++ programmers. They will not be in the next release of C++ because we want to get practical experience of their use so that their eventual inclusion in the C++ Standard will be well-founded. However WG21 will be working on the Technical Report aimed at release shortly after the next C++ Standard is released.

C and C++ Programmers, and Truthiness (Dan Saks) KEYNOTE

Sat 16:00, 45 mins (University)

Most programmers fancy themselves to be rational and objective, more so than the general population. Recent research suggests this self image might have a basis in fact. Nonetheless, C and C++ programmers still cling to programming styles and practices which are unsupported by evidence and sometimes even contradicted by it. Comedian Stephen Colbert has popularized the word "truthiness" to describe the human trait of knowing something "from the gut" without regard to actual facts. This talk takes a lighthearted look at C and C++ programmers' truthiness in the hope of inspiring more truthfulness.