Friday, 22 April

09:00

The Curse of Symmetry

• Room: Ballroom
• Track: Process
• Presenter(s): Jim Coplien, Technology Evangelist, USA
• Description:

  Computer science ever aspires to greatness. Nothing more than collections of iron and silicon primed with some energy states, computers have been praised and blamed for innumerable steps and stumbles in human progress. Whether it is Alexander's exhortations to use software to create the fabric of a living world, or Raskin's call to build humane programs, or Dijkstra's call for a true science of computing, our fellow citizens of Earth plead for programmers to wade the waters of the deep questions of existence. It's great keynote stuff, but what is the average programmer to do with these "insights"?

  As designers of software, it's good for us to know the basic structure of the stuff we're building. That understanding is subject to the more general notion of the basic structure of stuff, the fabric of the universe. We can find surprising insights in areas so distant from programming that we wouldn't expect them to be relevant; and for that reason, few visionaries have explored that terrain. Some of these insights provide strong metaphors for the daily conduct of programmers, for the design of computer languages, and for the basic structures of design.

  In this talk, we ponder the structure of structure itself through the eyes of symmetry. Nature has given us the curse of symmetry as a way of optimizing our mental processes. We let this illusion guide the creation of our programming languages and design methods. Yet the basic fabric of the universe is not symmetric, but rather broken. We find such brokenness in the fabric of cosmology (such as k-meson decay into pions), embryology (the way that tissue differentiation takes place), and biology (the fallacies of the Golden Mean and Fibonacci numbers). This brokenness is starting to show through in the design of software. The old symmetries of procedure calls and object-oriented subtyping have given way to AOP, multi-paradigm design, patterns, and generative programming: all techniques whose roots lie in broken symmetry. All of this evidence points to the need for a fundamentally new paradigm -- in the Kuhnian sense -- of system design.

10:00

Break

10:30

Model Driven Development -- Hype or Hope?

• Room: Room A
• Track: Process
• Audience Level: Easy
• Presenter(s): Frank Buschmann, Senior Principal Engineer, Germany
• Description:

  Model-Driven Development is an approach to software development that promises many benefits, from reduced development time and costs over better designed software to higher software quality. MDD is also advocated as a new and innovative idea, having the potential to revolutionize the way software will be developed in the future. But what is MDD in real-world practice: is it really the hope we are all looking for? Or is it more a hype that will fade away quickly because it cannot at all hold its promises?

  This talk gives an overview on Model-Driven Development. What is the general motivation, vision, and technical approach for MDD? What are the key prerequisites for using MDD successfully in your projects? What are the different flavours of MDD? In addition, this talks presents several MDD research activities and discusses experiences from applying MDD in real-world software development projects: what works, what doesn't work, what are the best practices and lessons learned, and what are still open issues.

The XP Game

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

  The XP Game is a playful way to familiarize the players with some of the more difficult concepts of the XP Planning Game, like velocity, story estimation, yesterdays weather and the XP lifecycle. Anyone can participate. The goal is to make development and business people work together, they both play both roles. Itís especially useful when a company starts adopting XP.

  This session was created by the XP Belgium group and more info can be found at www.xp.be/xpgame/

  Timetable:

  Icebreaker followed by 3 iterations (that include estimate/prioritize/develop/acceptance/retrospective steps)

What's New in EJB 3.0

• Room: Room B
• Track: Java
• Presenter(s): Scott Crawford
• Description:

  Full details to be announced

PayThyme - an Open Source Payroll System

• Room: Room E
• Track: Python
• Audience Level: Easy
• Presenter(s): John Pinner, MD, UK
• Description:

  The talk covers two areas, business and technical:

  • Business-wise, it will examine the reasons for developing PayThyme, the aspirations behind its business model, and the work involved in gaining commercial acceptability and Inland Revenue accreditation. The resolution of any conflict between the need to provide a fully-supported, credible, and income-generating product, and the desire to release it as genuine Open Source software, will be discussed.
  • Technically, the product itself will be demonstrated, and used as example software in showing the tools and methodologies used in developing GUI applications with Python, PyQt and Qt in the Thyme development environment. This will cover creating database table definitions (with information to speed GUI screen design), the automatic generation of GUI screen forms and maintenance programs from the table definitions, modifying the screens with Qt Designer, and enhancing the generated programs, with particular reference to using Thyme's data-aware custom widgets.

  Finally, we expect a healthy open discussion of both commercial and technical aspects.

C# for Interoperability

• Room: Room D
• Track: C++/C/C#
• Presenter(s): Richard Howells
• Description:

  Full details to be announced

12:00

Lunch & Vendor Presentations

14:00

Sprint driven development

• Room: TBA
• Audience Level: Easy
• Presenter(s): Jacob Hallén, CTO, Sweden
• Description:

  Sprints have become a key part of the development process for many Python projects, with Zope, PyPy and many other projects holding them regularly. This talk will explain how sprints work and look at key success factors for making them effective.

Wildcards in Java Generics

• Room: Room B
• Track: Java
• Presenter(s): Angelika Langer, Trainer / Consultant, Germany
• Description:

  Wildcards are a new language construct in Java that extends the Java type system by providing a type-safe abstraction over different instantiations of a parameterized class. Java programmers are confronted with wildcards such as “?” in numerous places in the Java Platform APIs of Java 5.0 such as the popular collection classes, but also in compiler messages.

  This tutorial explains the syntax of wildcards and wildcard bounds, and their use for instantiation of parameterized types. We discuss the purpose of wildcards and typical ways of using wildcard instantiations in interface and class design. In addition, the tutorial explains the role that wildcards play in the inference of type arguments of parameterized methods, including a discussion of wildcard capture, which is a mechanism that allows method to be called even though their type arguments cannot be inferred.

Concurrency Requirements

• Room: Room C
• Track: C++/C/C#
• Presenter(s): Hubert Matthews
• Description:

  Most work on concurrency up to now has been focussed on mechanisms such as locks, mutexes, semaphores - in other words: the tools. Very little has been done on understanding the requirements of the application and the expectations of users.

  This session seeks to reverse this imbalance and presents an approach for discussing and reasoning about concurrency from the user's point of view.

Patterns For Small Machines

• Room: Room A
• Track: Patterns
• Presenter(s): Charles Weir, Managing Director, UK
• Description:

  Now that Object-Oriented development has become mainstream, O-O environments are being used in many systems with limited memory: smart-cards, personal organisers, smart-phones and set-top boxes for example. And as applications become more sophisticated, even large mainframe and workstation applications may find themselves constrained. So a significant and growing proportion of the O-O community now face the problems of producing O-O systems subject to these restrictions. How can they satisfy their constraints without compromising the principles of object-orientation or limiting the functionality they provide?

  This talk will describe how to use O-O techniques in a memory-constrained environment. The speaker has made an intensive study of the approaches and techniques used by successful software developers for memory-limited machines. Using an approach based on design patterns this talk will explore a few of the most important of these techniques, and provide guidelines to implementing them.

A tour of two new Boost libraries.

• Room: Room D
• Track: C++/C/C#
• Audience Level: Medium
• Presenter(s): Thorsten Ottosen, Graduate Student, Denmark
• Description:

  This talk will present two new Boost libraries:

  • the Boost Range library (v. 1.32.0), and
  • the Boost Pointer Container library (v. 1.33.0).

  Boost.Range defines a new infrastructure for generic algorithms built on top of iterators. The new concepts make generic algorithms very fast and pleasing to use. We shall look at examples from the new string library in Boost and see how standard algorithms could look like in C++0x. We also briefly discuss how Boost.Range allows you to elegantly optimize certain types of problems.

  In the second part of the talk, we shall look at a new set of standard-like containers specialized for containing heap-allocated objects. The aim of the containers is to make OO programming easier in C++ by establishing a standard set of classes, methods and designs for dealing with OO specific problems. We shall look at how the classes are implemented in an exception-safe manner and discuss the advantages and disadvantages of a new set of containers compared to standard containers with smart pointers.

14:45

DocTest

• Room: Room E
• Track: Python
• Presenter(s): Michele Simionato, Developer, independent consultant and trainer, Italy

15:30

Break

16:00

Aspects in Python

• Room: Room E
• Track: Python
• Audience Level: Medium
• Presenter(s): Arno Schmidmeier, CTO Aspectsoft, Germany
• Description:

  Object oriented Programming have found its way into most projects. They enable a clean modularisation of the core functional requirements of the component, subsystem or application. Unfortunately, they fail in implementing the remaining non functional requirements in a modular way. Problems like tracing, logging, synchronisation, caching, pooling, auditing, security and exception handling, just to name some of them cannot be easily modularised. Even worse it is hard (if not impossible) to implement business functionality, which capture business rules, in a modular way in most architectures.

  Aspect Oriented Programming was successful applied in several projects to realise these functionalities in a modular way. AOP is therefore gaining quite a lot of interest in the past especially on the Java platform. Python does currently lack a full-blown AOP framework, which is no surprise, because Python have already everything built in, which is required for AOP. This presentation outlines the key concepts of AOP and how they can be easily applied in Python.

Paul & Jez's Stream-a-poloza

• Room: Room D
• Track: C++/C/C#
• Presenter(s): Paul Grenyer, Senior Software Engineer, UK, Jez Higgins, Programmer, United Kingdom
• Description:

  IOStreams is one of the lesser known areas of the standard library. While most people are now entirely comfortable slinging around std::vectors and std::lists, and know the difference between a std::map and a std::set, IOStreams is still rather opaque.

  Sure, writing an operator<< isn't too big a deal, and maybe the bold have even come up with a custom manipulator. But streams? Where do they come from? Where do they go?

  In a fun filled journey into the Standard Library's dark continent, we will attempt to illuminate the mysteries of IOStreams and reveal the streambufs beneath.

  Staring with a quick tour through IOStreams excitingly diamond shaped class hierarchy, we'll introduce the concepts of sources and sinks (i.e. Streams which read from or write to some external destination) and filters/adaptors (streams that modify data in flight). We'll also talk about some of IOStreams little idiosyncrasies – why some buffers might not actually buffer, and why read-only buffers sometimes need to be writable.

  By way of illustration we'll be walking through a logging stream. It writes log messages to an arbitrary number of other streams. The destination streams will be a combination of fstreams, stacks of filters, logging daemons on other machines, and whatever else we need.

"Issues" in the Design and Implementation of a Package using J2SE 5.0 Generics

• Room: Room B
• Track: Java
• Presenter(s): Russel Winder
• Description:

  Many people have been giving and will continue to give presentations about the generic type feature of Java 2 Platform Standard Edition 5.0 and how it has changed and will continue to change the way the Java programming language is used. Most of the examples used in these presentations are small and focussed on demonstrating the new features.

  In this session we will look at generic types from the perspective of having to introduce them into an existing, medium sized package. Not only will this enable us to look at how generics are used in a larger context than usual in presentations, it will require us to look at some of the problems and hassles of generics as well as the benefits. As a sideline, we shall see that the new for loop proves itself useful and we will see the wonders (!) of the enum concept that was also introduced in J2SE 5.0.

  Some of the architecture and design issues of building a medium sized package will also be raised and investigated during the session.

  The package in question is the ADS package written to be a pedagogical device in teaching and learning about algorithms and data structures. It is not a replacement for Collections and JGL but borrows ideas from both so as to show what package architecture and design are really. It has also turned into a vehicle for showing both the good and bad in the generics system of J2SE 5.0!

Writing Your First Pattern

• Room: Room A
• Track: Patterns
• Presenter(s): Kevlin Henney, UK, Allan Kelly, UK
• Description:

  Writing your first pattern or, Everything you ever wanted to know about pattern writing but were afraid to ask

  Anyone can write a pattern, but knowing where to start, what (not) to include, what form to adopt, how to write and how to get it generally accepted and communicated as a pattern can be daunting if you've never done it before.

  In this session Kevlin and Allan look at how patterns get written, what should be included in a pattern, who writes them and how the pattern community is important in improving patterns and developing pattern authors.

  The session is aimed at people who would like write a pattern but have never tried, or have tried and found it difficult. Those who don't specifically want to write patterns but would like to know what's involved should find also this session interesting.

Return to C++ (panel)

• Room: Room C
• Track: C++/C/C#
• Presenter(s): Nico Josuttis
• Description:

  Full details to be announced

16:45

Kamaelia - network protocol development with generators

• Room: Room E
• Track: Python
• Presenter(s): Michael Sparks
• Description:

  Kamaelia is an Open Source testbed for network protocol development using communicating Python generators

  I'll briefly describe how Kamaelia takes generators, wraps them with context, provides a pipeline/CSP style mechanism for communications. This will be followed by a concrete example of how network servers and protocols can be built using this mechanism. The system is inspired by asynchronous hardware design systems, and applying these techniques to network server design. The system differs from systems like twisted in that it takes a fundamentally different (more experimental) approach to handling concurrency, whilst still remaining single threaded. (And hence theoretically just as scalable)