Friday, 16 April

09:00

• Track: Process
• Presenter(s): Neil Martin
• Description:

  ISO 9001:1994 became obsolete on the 15 December 2003, we now live in the brave new world of ISO 9001:2000 We discuss what has stayed the same, what is new, and what the implications are for Software Developers when the Process Police arrive on the scene. How much process is enough, what has ISO 9000-3:2003 got to say on the subject of Software and Quality

10:30

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

  Multi-threading is a powerful addition to the programmer's toolkit. Unfortunately, threads are widely misunderstood and frequently abused. This talk explains the low level primitives used with threads in the Windows environment. The talk concentrates on the Windows thread implementation but the principles apply to threads in any environment and non-Windows programmers are very welcome. It gives a good grounding, beginning with what a thread is, moving through why you might want one to how you keep it under control. the talk provides a background to the afternoon's more advanced material from Kevlin Henney and Andrei Alexandrescu.

• Track: C/C++/C#
• Presenter(s): Alan Bellingham
• Description:

  This session looks at class design. When a programmer designs a class, she is naturally concerned with the functionality she needs from it, and will therefore provide suitable methods. However, any class designer also needs to consider other functions, whether those the compiler will automatically generate, or common utility functions that assist when the type is used with standard containers, serialisation and the like. Which functions need to be considered? Which functions should be members, which free? Which functions could be built on others? Does it matter whether the class uses object or value semantics? What about exception safety? These are questions that this session seeks to answer.

• Track: Process
• Presenter(s): Thaddaeus Frogley
• Description:

  Many modern applications take much longer to start up and initialize than you would expect. This talk explores why this is and presents a tried and tested approach for improving start up times by up to 300% or more.

  Attendees should expect to come away from the talk with a better understanding of where the bottle necks really are at load time, why load times matter, and a practical approach to improving their existing, future, or in development products.

• Track: Python
• Presenter(s): David Ascher
• Description:

  Python is at an interesting developmental stage. It's forgotten most of its childish roots, is being taken seriously by serious people, and yet is still looking forward to growth, not back to the good old times. What lays ahead? In this short keynote, I will present my personal perspective on how Python grew up to be what it is today, and possible directions that it could take as it continues to build both bone and muscle.

11:15

• Track: Process
• Presenter(s): Phil Nash
• Description:

  What is Organic Programming? Organic Programming is an exciting new way of thinking about development at all levels, and even beyond the workplace, that aims to get the maximum quality and quantity from any development effort.

  But what is it really?

  Organic Programming is a working title for a set of techniques, ideas and ways of working that constitute (or will constitute, as it is still evolving) a general approach to development, along with more specific "tracks", that try to take the "work smarter not harder" maxim as far as possible.

  Organic Programming is a lot more than that, but that is at the heart of it. It combines many elements from the Extreme Programming process, either verbatim or in a modified form, and other Agile Development Processes. But it also incorporates many techniques and principles put forward or expounded by Tony Buzan (inventor of the Mind Map (r)). Buzan's work is not technically oriented but is more concerned with the workings of the brain (and body) and how to best use them. It is the application of Buzan's ideas to software development, both at process and design and implementation level that makes Organic Programming especially interesting. This talk will introduce some of the key Buzan elements of OP and suggest how they can be used in a development project environment, and how their use can scale to all levels of the project. It will also explain why using these techniques and engaging in other non-technical pursuits can improve not just the quality of the designs and code, but of the designers and coders.

• Track: Process
• Presenter(s): John Crickett, Tristian Crickett
• Description:

  Have you ever thought of setting up your own business? Were you worried that you didn't know what to do, how to do it or what to charge? John and Tristan Crickett founded their business an Internet/Software Consultancy, Crickett Software Limited on September 11th 2001. Two and a half years on they recount the lessons learned, and explain how you too can setup and grow your own software consultancy.

• Track: Process
• Presenter(s): Stewart Brodie
• Description:

  Most revision control systems provide facilities for parallel development of software - usually using branches. Much of the introductory literature for revision control systems presents a branch-and-merge model as the natural way to develop bug fixes and enhancements, but the reality is that this leads to the creation of a lot of unnecessary branches leading to confusion where nobody is able to keep sight of the complete state of the software. I believe that the model is driven by the combination of the lack of even the most rudimentary configuration management and a failure to break down software into manageable components. I shall describe the methods of working that I've helped to develop during the past six years and their pros and cons with respect to avoiding unnecessary branching and adding trivial configuration management, plus the benefits seen from simplifying the revision control strategy to improve understanding of the state of the software

• Track: Python
• Presenter(s): Chris Withers, Simplistix
• Description:

  This is a tutorial in introduction to the Python language aimed at the large number of C, C++ and Java programmers present at the event who have not yet tried Python. It will cover the basic syntax, structure and features of the language, and attempt to convey the strengths behind its growing popularity, and show how it can complement

• Track: Python
• Presenter(s): Alex Martelli
• Description:

  Iterators, generators, new-style classes, Unicode, metaclasses, zip archives - The Python language has evolved considerably in the last few years, with a host of powerful new features. This tutorial is for all those who thought they knew the language from a long time ago and have become stuck in a rut. It will cover new features in the 2.X series, new patterns idioms made possible

12:30

• Track: C/C++/C#
• Presenter(s): David Burggraaf, Microsoft Corporation
• Description:

  Whether you are pushing the language envelope on the templates front, evolving large applications, prototyping new ones, or looking forward towards future OS's and platform features, Visual C++ is all about helping you realize and maximize your potential. Come and see the latest features in Visual C++ 2003. Learn about the significant enhancements to the developer environment, the compiler, and other tools. Also, get a sneak peak at what is coming for the next release of the product.

14:00

• Track: Process
• Presenter(s): Jutta Eckstein, Nico Josuttis
• Description:

  (Disclaimer: This isnt an esoteric talk about how to stay healthy when growing older ;-) )

  Agile Methodologies, Eclipse, J2EE, Test-Driven-Development, and Fit are the current buzzwords. But what do they really mean? And will they also work for mission-critical projects?

  In this talk we present a project in which we developed a complex content management system, by successfully applying and combining agile practices, Eclipse and the acceptance test-framework FIT. The content management system that has been developed in best time, combines all different repair and maintenance instructions for a worldwide leading automobile affiliation group. This talk presents the most noteable insights and factors for success. To be more precise, we will talk about

  • using Eclipse as a client platform,
  • an agile process, that supports a project with 30 team members,
  • the combination of requirements, acceptance-tests with the wiki-web and the running system,
  • the show-stopper and their elimination
  • and the successful combination of all these technologies and practices

• Track: C/C++/C#
• Presenter(s): Kevlin Henney
• Description:

  At last year's ACCU conference a model for multi-threaded programming in C++ was presented that was based on a more fully generic-programming style than found in other C++ threading designs. The model covers both the threading and the synchronisation sides of working with threads. This year's talk recaps and reflects on the generic model, and includes some examples that illustrate its practical application.

• Track: Java
• Presenter(s): Arno Schmidmeier
• Description:

  Modern distributed component computing and its platforms like J2EE and .NET have found its way into quite a lot of projects. They remove the burden of architecting, designing and implementing some non functional core requirements like transaction handling, persistence and distribution. They promise an unexpected level of software productivity in conjunction with modern programming techniques like refactoring.

  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 can not be modularised. Even worse it is hard (if not impossible) to implement business functionality, which capture business rules, in a modular way in most architectures.

  The results are source code fragments, which do belong to one functionality (and of course this functionality should be stored in exactly one module), but these fragments are spread out through the whole code base. This has several severe impacts on the software development process:

  • It reduces the reusability of components, because they are often limited by non functional limitations, which are not defined by the problem domain (e.g availability of a specific logging API, some security/ auditing constraints, etc. )
  • It reduces the productivity of the developer, because they cannot focus on just one requirement, but they have to implement totally different requirements at the same time.
  • Developers must manually insert redundant code in plenty of places, just to fulfil company policies for some major non functional requirements. This boring and expensive manual task makes it hard and costly to maintain and evolve the code base, because simple and necessary changes can not be performed in a single place.

  Aspect oriented software development (AOSD) is the next programming paradigm, which eliminates these problems. The current focus of AOSD is on aspect oriented programming (AOP). Early adopters from research and industry have gained great productivity improvements with AOP. MIT considers therefore AOSD as one of the top 10 technologies for the next 10 years. This presentation explains the concepts and ideas behind AOP on Java and AspectJ code fragments. However the ideas and concepts are similar by other AOP-languages like AspectC++ and AspectS and also by AOP Frameworks like AspectWerkz, Nanning, Jac, JBoss AOP-API.

• Track: Python
• Presenter(s): Chris Withers, Simplistix
• Description:

  This is the beginning of a strand of talks designed to follow on from the Test Driven Development workshops and talks. It will cover Python's support for unit testing, which is highly similar to JUnit, and will explain why Python is the most productive testing tool for C++, Java.

• Track: Python
• Presenter(s): Peter Shima
• Description:

  The financial industry is known to be aggressive in adopting new technology, both in hardware and software. However, not too much is known about how much open-source technology is utilized. This talk is a brief introduction to how Python is used in the financial industry, and shares some personal experiences in raising Python's popularity within the industry.

  Peter Shima, with over 15 years of experience in the financial industry and over 10 years of experience with python, explains how python is being used in real-life applications. The scope covers both the programmer's point of view and the senior IT management's point of view.

14:45

• Track: Python
• Presenter(s): Duncan Booth
• Description:

  This will provide an overview of the basic tools and techniques needed to script, and thus automate or test applications written in C and C++. The Python/C API, basic construction of extension modules, and will survey and point attendees towards a number of frameworks making it easier such as SWIG, CXX and Boost.

• Track: Python
• Presenter(s): Marc-André Lemburg
• Description:

  Python is widely and somewhat inaccurately referred to as a scripting language. While Python is an ideal platform for small scripting tasks, it does in fact cover all the concepts needed for large scale object oriented application development. However, complex applications bring different challenges. This talk will draw on the speaker's experience with large scale application development using Python as central implementation language and provide a cookbook approach to the problem.

16:00

• Track: C/C++/C#
• Presenter(s): Angelika Langer
• Description:

  In principle, implementing binary operators such as operator= and operator== is fairly easy for simple types, but is amazingly demanding for a class hierarchy of types. In this tutorial we will look into the complexities and will discuss solutions. The core of the problem stems from the fact, that objects in a class hierarchy have something in common, namely their base class part. For this reason, it makes sense to consider mixed-type operations where objects of different types from the same class hierarchy are assigned to each other or compared to each other. Does it make sense to allow mixed-type operations, and if so, how can they be implemented correctly? This is an intermediate session aimed at C++ programmers, requiring a basic knowledge of C++.

• Track: C/C++/C#
• Presenter(s): Andrei Alexandrescu
• Description:

  Would you like to have your compiler tell you "Error: This call will lead to deadlock"? This talk presents new idioms for C++ multithreaded programs, including multithreaded transactions involving multiple objects. You can have your compiler detect not only race conditions, but deadlocks as well.

• Track: Java
• Presenter(s): Arno Schmidmeier
• Description:

  This is a practical session, where we will do some audience programming. So you will see plenty of Java and AspectJ code live in action. First I will start with a small sample program, from a real world project. We will discuss what we have and what we can do, to fix the missing exception handling and how to do it best.

  For this approach I will use AspectJ and a very small Aspect-library with the help of the audience to get the job done. As we work with an existing code base we will use refactoring and modern IDE tools. So you will see how modern IDEs, Aspects and refactoring work hand in hand, what does work and what doesn't.

  This practical session targets developers interested in practical use of Aspect oriented programming. It requires some base knowledge about Aspect oriented programming, what you can easily get in the session: Introduction to Aspect Oriented Programming.

• Track: Python
• Presenter(s): Samuele Pedroni
• Description:

  Jython is an implemention of Python written in Java, and it enables seamless two-way communication between Java and Python code. This has allowed Jython to become the scripting language of choice for Java applications. This talk will provide a rapid introduction, showing how to add scripting capabilities to Java applications, and thus how to use quick-to-write Python scripts to automate and test substantial Java frameworks efficiently.

• Track: Python
• Presenter(s): Armin Rigo
• Description:

  Psyco accelerates the standard Python interpreter transparently, using just-in-time specialization techniques. It is a C extension module with no change in the interpreter, and works by generating specialized machine code on the fly. This talk gives a quick overview on the use of Psyco, and then focuses on the involved techniques.

16:45

• Track: Python
• Presenter(s): Andy Robinson
• Description:

  This tutorial will cover the basic of creating COM clients and servers in Python, passing data types back and forth across the boundary. It will show you how to add a poweful macro language to Windows applications in a few lines of code, and to control, test and automate Windows applications.

• Track: Python
• Presenter(s): Armin Rigo
• Description:

  PyPy is a rewrite of the Python interpreter in Python. Since its first announcement, PyPy has struck a chord, and the PyPy team has been working through regular sprints around Europe. It has the potential to bring together all the 'alternative implementations' - PyPy itself, Jython, PsyCo, Stackless, perhaps even .NET.

  We will see the architecture of the project: the interpreter, the "object spaces", and the translation process. The latter is used to produce efficient low-level code which can be a Python interpreter similar to the standard CPython, or a Stackless version of it, or even a "symbolic Python interpreter" just like Psyco is.

19:00