Thursday, 21 April

09:00

Improving the Support for Generic Programming

• Room: Ballroom
• Track: C++/C/C#
• Presenter(s): Bjarne Stroustrup, Professor, USA
• Description:

  Generic programming (incl. "template meta-programming") has been the major area of growth of C++ techniques and consequently is the area where the language features are under the greatest strain. I will present the key problem areas and outline solutions currently being worked on. The major proposal is "concepts" - a type system for template arguments aimed at separate checking of template use (in isolation from template definitions), template overloading, and vastly improved error messages. Other issues is how to allow more general, flexible, and efficient initialization (generalized constructors and general initializer lists), use of template aliases, and implicitly typed valiables (decltype and auto).

10:00

Break

10:30

The Evolution of C++

• Room: Room A
• Track: C++/C/C#
• Presenter(s): Bjarne Stroustrup, Professor, USA
• Description:

  A good programming language is far more than a simple collection of features.

  My ideal is to provide a set of facilities that smoothly work together to support design and programming styles of a generality beyond my imagination.

  Here, I outline rules of thumb (guidelines, principles) that are being applied in the design of C++0x. For example, generality is preferred over specialization, novices as well as experts are supported, library extensions are preferred over language changes, compatibility with C++98 is emphasized, and evolution is preferred over radical breaks with the past.

  Since principles cannot be understood in isolation, I very briefly present a few of the proposals being considered in the ISO C++ standards committee.

Intro: The Python Year

• Room: Room E
• Track: Python
• Presenter(s): Andy Robinson, CEO/Chief Architect, ReportLab Europe Ltd., Greg Stein, Engineering Manager, Google (among others), Google, USA
• Description: A brief session will introduce the Python track, covering any administrative matters, and provide a roudup of development in the Python world over the last year.

C++ Design Experiences: Generative Programming Goes Live!

• Room: Room D
• Track: C++/C/C#
• Presenter(s): Mark Radford
• Description:

  Four years have passed since the publication of "Generative Programming: Methods, Techniques and Applications" by Krzysztof Czarnecki and Ulrich Eisenecker, a book that captured my interest along with that of many other people. Although not as generally applicable in day-to-day work as (say) Generic Programming, Generative Programming and its associated techniques are tools in the software development toolbox.

  This presentation will fall into two parts. In the first, I will present an introduction to Generative Programming and a discussion of the tools and techniques that support its implementation. In the second part, I will present examples of practice together with discussion of their practical merit.

Refactoring

• Room: Room C
• Track: Process
• Presenter(s): Rachel Davies, Agile Coach, United Kingdom, Duncan Pierce, Process Consultant, UK
• Description:

  Note that laptops are required for participants!

  Most software gets new requirements over time. The accumulated changes often stress the original design in unanticipated ways. When this happens, the software often gets more and more difficult to work with: development slows down, or more bugs appear. Sometimes it becomes so difficult to add new functionality or prevent new bugs creeping in that it seems easier to give up and rewrite the system from scratch.

  This can be avoided by refactoring.

  Refactoring breathes new life into code by changing the way it is written without changing what it does, keeping the code malleable and ready to accept change. It works in small, easy steps, and requires no big investment.

  This tutorial introduces and explains refactoring in a hands-on tutorial. After this tutorial, attendees will be able to refactor mercilessly to keep their code maintainable, ready for new functionality.

  This is based on the TDD tutorial format developed by Ivan Moore, in which we work slowly through an example with the audience and discuss what is happening, what the next step should be, and so on. Most of the learning comes from open discussion and demystification of the refactoring process.

  Attendees will learn how to:

  • make code more readable
  • make code easier to change
  • make the domain model more apparent

  We will start with some code (not very good code) and a good automated test suite. After we have talked briefly about what the code does (in conjunction with the tests) we will look at a change we need to make to it, and explore with the participants why this change cannot be made easily with the code as it is.

  Then we will begin to refactor. We identify a pressing but small problem that is holding us back, and proceed to solve it by a simple refactoring, which the participants also perform on their laptops. I expect that at the start there will be much discussion about the value of such small changes, and that the participants will initially struggle to see how small refactorings can make a big improvement in the code.

  As we proceed, the participants will be encouraged to take more responsibility for identifying problems and suggesting refactorings, using simple guidelines like looking for duplication. I will encourage participants to work separately from the presenter to come up with their own refactorings, which we will all discuss. In this way, participants will learn how to create and apply their own refactoring steps.

  At the end, if there is time, we will run a comparison of the original and final code so that participants can see how far we have come, even though the steps were small.

Women In Computing (Panel)

• Room: Room B
• Track: Process
• Presenter(s):
• Description:

  From a quick glance around most of our workplaces, not to mention at our fellow conference delegates, it is clear that women pursue careers in software development far less often than men do. But why should this be so?

  In this panel a range of women discuss their experience of working in a technical field like computing, the factors which can work against women in the industry, and how they have dealt with them.

  Is there actually direct discrimination at play, blocking women's entry or progress, or is it mainly subconcious behaviour that tends to reinforce the status quo? And are there steps that should be taken to improve the situation? Finally, what are the advantages that women can bring to, and benefit from, working in the computing field?

11:15

Something Cool in C++0x

• Room: Room A
• Track: C++/C/C#
• Presenter(s): Herb Sutter, Architect, Microsoft Developer Division, USA
• Description:

  What will the topic be? Lambda functions? Threads? Security? Whatever it is, it will be cool, exciting, and relevant to the near-term future of C++. There might even be two cool things! Come to listen or come to debate, but most of all come and enjoy.

Keynote: Python at Google

• Room: Room E
• Track: Python
• Presenter(s): Greg Stein, Engineering Manager, Google (among others), Google, USA

12:00

Lunch & Vendor Presentations

14:00

Unit Testing XSLT Stylesheets

• Room: Room C
• Track: Java
• Presenter(s): Jez Higgins, Programmer, United Kingdom
• Description:

  XSLT is now a mature technology. It's widely used in web, document composition, electronic and print publishing applications, among others. Increasingly, XSLT styling isn't the last little bit at the end to create the HTML, but at the core of document creation and processing pipelines. Indeed it isn't uncommon, particularly in publishing applications, to have multiple XSLT transformation steps chained one after the other. XSLT stylesheets are getting larger and more complex, containing significant chunks of business logic.

  XSLT, while addressing the specific issue transforming XML, is Turing complete. It's a real programming language, and people are doing real work with it.

  Development is easier with automated testing. That's a given. That's why Ant integrates JUnit, and why C++ programmers up and down the land spend hours developing test harnesses because CppUnit just *isn't* quite right.

  How do you test an XSLT stylesheet?

  In this talk I'll present a tool for XSLT testing. Tests are described in an XML vocabulary. The test definitions are cranked through a set of XSLT stylesheets to generate Java source, more XML and yet more XSLT. The Java sources are JUnit test suites which drive the XSLT test procedure. It's all stitched together with Ant.

  While the code presented is obviously in Java, the approach described can be applied to any language where suitable tools exist and could easily be ported to, say, C# or Python.

Like Reflection in C++ with Typelists

• Room: Room D
• Track: C++/C/C#
• Presenter(s): Avraham Zilberman, Technical Consultant, Israel
• Description:

  This talk will be on how to implement "like reflection" in C++:

  I will show an example of a TicTacToe game where you can choose 2 player out of a few player types (HumenaPlayer a ScanPlayar and a RandomPlayer).

  Now in C++ when the user chooses this option you have to enter into a switch case that checks for the option and creates the approporiate Player instance. And then since all players implement a common interface then you can use polymorphism. In C# we can bypass the switch case code using the Reflection feature.

  I will show how to make this bypass in C++ with templates and TypeList.

  Session Plan:

  • Introduction
  • The problem
  • The reflection feature in C#
  • Templates and partial sepcialization
  • Typelists
  • Final solution.

Proposed Extensions and Enhancements of classes

• Room: Room A
• Track: C++/C/C#
• Presenter(s): Francis Glassborow
• Description:

  The class concept is central to C++. In this presentation I will introduce two of the major proposals for changes to classes in the next full C++ Standard. The first of these is the explicit class concept which is a mechanism to suppress all implicit compiler generated special member functions and substitute a mechanism for explicit requests for compiler generation.

  The second major, and more contentious, proposal is to provide a mechanism for extending existing class interfaces (both public and private). The extension of public interfaces will address the issue of unifying the syntax of member functions (that have access to private members) and non-member functions (that have no such access). The extension of the private interface will allow the private interface of a class to be made invisible to the user.

90 Minutes From The End

• Room: Room B
• Track: Patterns
• Presenter(s): Mark Prince, Andy Schneider
• Description:

  The end game is an oft forgotten phase in a software project, despite the fact it can make or break a project. Successful project managers and technical leads seek to ensure their project follows a controlled glide path to a successful conclusion. However, things can and will go wrong and then success is characterized by an ability to adapt and change to meet and manage new challenges. In '90 minutes from the end' you will learn 10 tried and tested practices for successfully closing out the end game.

  Be prepared to contribute as the latter part of this workshop will focus on identifying other key practices that you have used to successfully close out the end game.

  Target Audience: people with an interest in or experience of leading teams or projects.

Keep it simple with Pythoncard

• Room: Room E
• Track: Python
• Presenter(s): Kevin Altis, United States of America

14:45

Birds of a Feather

• Room: Room C
• Track: Process
• Presenter(s): It could be you...
• Description:

  Birds of a Feather sessions are arranged at the eventitself, based on subjects suggested by delegates.

  That means if you have a topic which you want to discuss, or present to the conference, get in touch with the conference organizers to book this slot!

Bringing a C Library Into The Future

• Room: Room D
• Audience Level: Easy
• Presenter(s): Dirk Haun, Software Engineer, Germany
• Description:

  Compart is a company specialising in software for high-volume document conversion, formatting, and processing. Most of the functionality required in this field is concentrated in a highly portable C library, on top of which the actual applications are built.

  With the advent of new languages and frameworks, it is becoming increasingly important to make this functionality available in these environments. To bridge the gap, an abstraction layer based on an XML IDL has been developed. From this IDL, both bindings and code can be generated automatically, providing native objects in languages such as Java and JavaScript. It also offers the possibility to make the connection to e.g. the .NET framework.

  The XML IDL has since become the de facto reference for the interface definitions, so that now the actual C header files for the underlying library can be created from the IDL. As an added bonus, the IDL is also used for documentation, with an XSLT script creating DocBook from the IDL.

  After introducing the environment, the session will, as a case study, describe how these techniques are used to provide customers with a JavaScript scripting environment in which they can operate on abstractions of objects they are familiar with, such as documents, sheets, pages, etc.

Rvalue References, Move Semantics, and Argument Forwarding

• Room: Room A
• Track: C++/C/C#
• Presenter(s): David Abrahams, Principal, Boost Consulting, United States
• Description:

  This talk describes a new kind of reference that fills a crucial hole in the C++ type system. Rvalues arise most commonly as objects constructed in-place, e.g.

  std::ofstream("logfile", std::ios::app)

  and as the result of calling functions that return by-value, e.g.:

  std::make_pair(x, y)

  A non-const rvalue reference can bind to non-const rvalues, yielding two major benefits:

  • Order-of-magnitude performance improvements in the manipulation of heavyweight types like strings and vectors: they can often be "moved" where they currently must be copied. Movable types can allow us to write code that's more natural and more generic without fear of poor performance.
  • The ability to write "forwarding" interfaces that perfectly preserve the relationship between arguments passed and the function being forwarded to, including movability. Forwarding is a common and neccessary element of C++ library designs such as the boost/tr1 bind and function libraries, and even simple generic functions like std::make_pair.

  A whole host of minor advantages also accrue, such as the ability to better manage non-shareable resources such as mutexes.

15:30

Break

16:00

eXtreme Programming eXperienced

• Room: Room D
• Track: Process
• Presenter(s): Tom Guest
• Description:

  This presentation reports back on two very different projects which tried hard to adopt eXtreme Programming (XP): not to cherry pick the good bits, not to pay lip service to a trendy methodology, but to try and do XP by the book.

  The presentation does not attempt to describe what XP is -- a basic knowledge, or at least interest, is assumed. Instead, it concentrates on what worked, what didn't, what we enjoyed, what we endured, and what we'd do differently next time.

Modern scalable 3-tier architectures

• Room: Room B
• Track: Process
• Presenter(s): Nico Josuttis
• Description:

  Too often people assume that simple rules, designs and architectures of small systems and prototypes should be used for large systems. But for large systems in large projects things change significantly. For example, it's usually too expensive to be perfect, interfaces become more generic, and the team spirit becomes more important. Based on his experience of developing large mission-critical systems with up to 200 developers, for thousands of users and dealing with millions of customers, Nicolai Josuttis presents some of the most important experiences and lessons learned.

Viewing Software Development as Learning

• Room: Room C
• Track: Process
• Presenter(s): Allan Kelly, UK
• Description:

  In this presentation Allan present a new view of software development. He considers development activities as an exercise in learning: learning about software, learning about problems and learning about the process. Applying established theories of organizational learning he discusses aspects other metaphors may over look and presents some new ideas on how we can improve our ability to learn and develop software.

Developing Packaging and Distributing Cross Platform Desktop Applications with Python

• Room: Room E
• Track: Python
• Presenter(s): Nathan Yergler, Software Engineer, USA

Evolution of C++ (panel)

• Room: Room A
• Track: C++/C/C#
• Presenter(s): Francis Glassborow, Bjarne Stroustrup, Professor, USA

16:45

The Unnamed Process: doing agile with C++, Python, and a tailor-made process

• Room: Room D
• Track: Process
• Presenter(s): Giovanni Asproni, Independent Consultant, UK
• Description:

  This is an experience report on the successful implementation of a custom agile methodology in a real-life project.

  The promise of agile methodologies is to make software development faster and, at the same time, have higher code quality, higher customer satisfaction, and happier programmers. This is very appealing! However, their implementation is not easy,

  In fact, introducing a new methodology—and more generally, any kind of change—in an organisation may create several technical, human, and political problems. I'll describe the choices my team and I made in order to minimise their occurrence, and how we managed to solve the ones we faced.

  Finally, I'll describe the process with the rationale behind it, and I'll show the reasons why we decided not to pick an out of the box one as Extreme Programming.