ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Session details

Conference 2008

Sponsored by:
Oxford University
Organized by:
Conference Chair:
Giovanni Asproni
Conference Committee:
Aaron Craigie
Francis Glassborow
Alan Lenton
Ewan Milne
Tim Penhey
Event Manager:
Archer Yates Associates Ltd
Threshers Yard, West Street
Kingham, Oxon. OX7 6YF
Phone: +44 (0) 1608 659900
Fax: +44 (0) 1608 659911
Email: julie at

Tuesday 01 April 2008

EVO: The Evolutionary Project Management Method. Practical Rules, Principles & Templates to Practice Evolutionary Project Management (Tom Gilb) {Slides}

Tue 10:00, 360 mins (University)

A practical and proven way to manage any project with focus on high, immediate, measurable, estimated, continuous, stakeholder-value delivery

Fun with Erlang (Joe Armstrong)

Tue 10:00, 360 mins (Cherwell)

"Fun with Erlang" is a one day tutorial designed to give you some feeling for what you can do with Erlang.

During the day I will attempt the impossible - we'll try and make a networked application, then we'll show how to make the application fault-tolerant and how we can go in and change it on the fly without disrupting the service.

We'll start with a lightning tour through Erlang - highlighting those parts of the language that we'll use to make our application.

In the afternoon we'll build and run the application, this will run on the laptops in the classroom.

If you're going to actively participate you'll need a laptop with wireless connectivity and the latest version of Erlang installed. I'm not going to tell you how to Install Erlang. If you can't do this you're looking at the wrong tutorial.

SOA in Practice (Nicolai Josuttis)

Tue 10:00, 360 mins (Blenheim)

SOA (service-oriented architecture) is hype. According to Gartner, by 2008 SOA will be the basis for 80% of development projects. However, projects behind this hype are still rare. There might be a lot of technical knowledge out there regarding SOA, but its key success factors include processes and organizations.

In this tutorial, Nicolai Josuttis will separate the SOA hype from reality. As a team leader of the realization of a SOA at a world-wide phone company with a heterogeneous infrastructure with more than 10 million service calls per day, he knows about the big difference between was is being said and promised about SOA and what it means in practice to run a SOA in a large and heterogeneous environment.

The tutorial will cover the following topics:

  • Large systems and loose coupling
  • SOA as a concept
  • Classification of services
  • Message exchange patterns
  • Service lifecycles (incl. versioning)
  • The impact of performance and security
  • Web Services
  • Service management (repositories)
  • Model-driven service development
  • Organizational consequences
  • The business case of SOA
  • Establishing SOA

Wednesday 02 April 2008

Value delivery for Agile environments (Tom Gilb) KEYNOTE {Slides}

Wed 09:30, 60 mins (University)

The primary purpose of any IT/software/development/maintenance project should be real tangible lasting delivery of stakeholder-needed value. This value needs to be expressed and measured in terms of qualitative and quantitative improvements in the stakeholder environment; not in terms of designs, functions, stories, use cases, strategies, architectures; or other means to get the value.

Both current agile methods, and most other software methods, are almost 100% focused on ‘what we need to code’, rather than what we need to do to actually deliver the value needed.

Indeed, we have focused too much on the customer or user alone, and not all the other stakeholders.

This talk will suggest that we need to add a development infrastructure to conventional programming methods, agile and not, in order to focus our attention on what stakeholders really want. We need to quantify the multiple dimensions of value, and be prepared to design towards reaching these values. We need to measure partial and full delivery of these values in the stakeholder environment, incrementally. A value manifesto and some value principles will be suggested.

SOA with Web Services in Practice (Nicolai Josuttis)

Wed 11:00, 90 mins (University)

Web Services are considered to be the de-facto standard for the technical realization of a SOA landscape. This might lead to the impression and expectation that with Web Services all problems are solved. However, this is not the case. Web Services have significant limitations so that a lot of additional effort is necessary to use them in practice. In addition, due to its open standardization process they might not necessarily lead to interoperability.

In this talk, Nicolai Josuttis presents the most important issues you have to know and consider when using Web Services in SOA practice. Based on several practical experiences (including running an international SOA bus with millions of service calls per day), he will provide important insights to the chances and efforts Web Services from a conceptual point of view provide in reality.

Programming on a network - writing programs in a networked world (Roger Orr) {Slides}

Wed 11:00, 90 mins (Cherwell)

Networks now seem almost omnipresent - whether globally with the Internet or within a company on the intranet. As a result an ever increasing proportion of our programs are now network aware. What general techniques are there to help us produce programs that work well in networked environments?

In the early days of local area networks there were attempts to provide complete location transparency, but in practice the sort of issues brought by the network means that its existence can rarely be totally ignored. There are many different ways in which the presence of a network affects an application, such as:

  1. performance, when the network becomes the bottleneck
  2. scalability, how to ensure the application copes with increasing load
  3. security, especially across the Internet
  4. versioning, so you can update the application piecemeal
  5. flexibility, for example supporting different programming languages
  6. supportability and maintainability to ensure problems can be found and fixed as easily as possible

The presentation assumes some experience of writing code in a network environment, but it does not demand expert knowledge of networking protocols or in-depth knowledge of specific programming languages.

Santa Claus and other methodologies (Gail Ollis) {Slides}

Wed 11:00, 90 mins (Blenheim)

I don't believe in methodologies. That's just my opinion; so what? Reactions to it frequently appear polarised - outrage or agreement - but both open the door to a more useful examination of a rather bald statement. It turns out the poles may be closer than you think.

In this session I will explain why I became a cynic (or realist, depending on your point of view!) about methodologies, and how that has been much more constructive than it sounds. Santa Claus takes a title role to help demonstrate that it's not always necessary to believe in something to make good use of the stories that surround it. Ultimately, this session is really all about problem solving: adopting ideas that fit, setting aside the remainder, and knowing the difference.

Bits And Mortar (Ric Parkin) {Slides}

Wed 11:00, 90 mins (Charlbury)

Software development has taken a lot of ideas from Architecture over the years, from the overarching vision of the Architect to Patterns and Pattern Languages.

In this talk we'll examine why this has been such a fertile analogy, looking at the history of some well known concepts that have made the transition, illuminate others who's parallels aren't as well known, and introduce some novel ideas that will change the way you look at the code you write - and the buildings you use.

Whether it's Patterns, High Road verses Low Road approaches, Agile methodologies (and the counter-example of Waterfall), planning using Scenario Buffering, office organisation, recognising Shearing Layers, exposing history via Archaeological digs, or just the way buildings - and software - change and adapt over time during construction and maintenance, there's sure to be something you'll recognise and something you'll take away and use.

The Challenges facing Libraries and Imperative Languages from Massively Parallel Architectures (Jason M. Mcguiness, Colin Egan) {Slides}

Wed 11:00, 90 mins (Wolvercote)

The challenges of writing programs for parallel architectures has become an ever more prescient in the light of the pervasiveness of desktop multi-core processors and readily available consumer grids. This may be seen as an effective increase in instruction retirement rate via the multiple cores of execution that have been made available to the programmer. This has, in turn, exacerbated the memory wall, the rate at which data can be read from and written to main memory via the various memory hierarchies of super-scalar processors.

The research community has long been investigating these issues through research into data-flow, VLIW and multi-core systems, and there is considerable effort into researching processor-in-memory (PIM) architectures, such as the IBM Cyclops family. PIM architectures achieve high performance by increasing the bandwidth of the processor to memory communication and reducing that latency, via the use of many processors physically close to the main memory.

These massively parallel architectures may have sophisticated memory models, for which I contend that there is an open question regarding what may be the ideal approach to implementing parallelism, via using many threads, from the programmer's perspective. The issues raised by these massively parallel architectures are relevant to current systems: blade frames may contain between 4-8 processors per blade and have between 5-20 of these blades per frame, giving of the order of 20-160 processors. This is a reasonably large quantity of parallelism, in a NUMA architecture, for the programmer to manage.

The author's experience of writing programs for PIM architectures was obtained using DIMES (the Delaware Iterative Multiprocessor Emulation System), which is being developed by CAPSL at the University of Delaware. This is used as a hardware evaluation tool for such cellular architectures. As the programming example, the author chose to use a threaded Mandelbrot-set generator with a work-stealing algorithm to evaluate the DIMES cthread programming model. This implementation was used to identify potential problems and issues that may occur when attempting to implement massive number of very short-lived threads.

From this research the author contends that the combination of language features with carefully chosen library-based abstractions is the optimum combination for imperative languages. Languages such as UPC, HPF mainly focus upon loop-level parallelism, alternatively parallelism may be created within the compiler using trace-scheduling or list-based scheduling? Or should it be at a library-level, for example OpenMP or POSIX-threads? For general purpose programming, loop-level parallelism may be insufficient, and the use of the current libraries has led to a folklore in the programming community that writing parallel programs is hard. Therefore, these abstractions must be carefully chosen, because of the fact that locking used within threading is not compose-able, which can seriously undermine modern program construction using functional decomposition or object-orientation.

How to become Agile (Jutta Eckstein) {Slides}

Wed 14:00, 90 mins (University)

According to Forrester Research 14% of the enterprises both in the USA and in Europe apply an agile approach and another 19% consider to get started with agile. A lot of companies want to become agile because they regard agility as a promising development approach, not only because the Standish Group is recommending agile development processes for avoiding project failures. Yet, many teams are uncertain about how and where to start in order to become agile. Moreover, transitioning to agile often has an impact in many dimensions that are difficult to foresee. In this talk, Jutta provides insights in how to get started with agile, what pitfalls to watch out for in the transition phase and as well how to ensure that the agile mindset will be preserved.

Practical Multi-Threading (Dietmar Kuehl) {Slides}

Wed 14:00, 90 mins (Cherwell)

As was established at previous conferences, multi-threading will become mainstream soon with multi-core machines becoming common place. This presentation explains techniques and requirements for multi-threaded programming. It discusses the underlying memory model and how this relates to the use of low-level facilities likes atomic operations, thread synchronization primitives, and higher-level thread building blocks. The aim is to provide a safe basis from which to work. This presentation is mostly intended as a starting point for multi-threaded programming in general with concrete examples drawing from the upcoming C++ multi-threading facilities.

This talk will address

  • a high-level view of modern multi-process architecture to emphasize the need for synchronization between cores for performant programs
  • the semantics of memory barriers and their relationship to atomic operations
  • use of explicit synchronization mechanisms (mutex and condition variables) and opportunities to avoid excessive costs
  • higher-level abstractions hiding away some of the low-level details based on tasks (basically Thread Building Blocks).

Error Handling and Diagnosibility: Requirements, Policies and Patterns (Tony Barrett-Powell) {Slides}

Wed 16:00, 90 mins (Cherwell)

This session explores error handling and diagnosibility what it is, what it means in terms of requirements, development and use, and finally presents a selection of design patterns for error handling that provide the bedrock for good diagnosibility.

Error handling is the means by which a system processes unexpected situations and informs the concerned parties what happened. Diagnosability takes this further and provides these parties with the relevant information to diagnose and correct the problem. Software without good error handling or diagnosibility is usually deemed low quality as it is difficult to get, and keep, running.

This session looks at the needs of the concerned parties: end-users, operators, testers and developers to understand what each expects of error handling and how these requirements influence the development of an error handling strategy for a project or system. It also considers where, in the main, software lets these concerned parties down.

The session explores the development of an error handling policy document, based on the requirements of the concerned parties, and how this can be used as guidance during development.

The session continues by exploring a selection of error handling patterns (from a pattern language by Eoin Woods and Andy Longshaw), how these provide solutions to the requirements of a particular party and the impact on the usefulness of error reports emitted by a system.

The session concludes with a round up of the material presented and pointers to further reading.

Tools, Frameworks and Libraries: the Devil's work or Manna from Heaven? (Mike Hill, Giovanni Asproni)

Wed 14:00, 90 mins (Blenheim)

What happens when you put together a crack development team and get them to decide which tools, frameworks and libraries they'll need to do the job? Will we get (a) a happy consensus reached by rational argument, (b) a never-ending irrational argument about which automated testing frameworks to use? We're not sure what to expect, but we're looking forward to finding out what YOU think is important!

Shared love, Shared pain

In this session, we want to the attendees to argue amongst themselves (in small groups) about what's important to consider when choosing tools, frameworks and libraries for your greenfield project. We want you to share your experience, and hear from others.

For example:

  • What's most important to avoid?
  • What's important to look for?
  • What's not important at all?
  • When is it simpler to use an additional tool/framework/library?
  • When is it appropriate to choose to use a framework today because it will probably be useful in the future?
  1. Brainstorm what tools, frameworks and libraries have you used or been forced to use in the past year. Get people to write up on sticky notes and group them. (15 mins)
  2. Divide people into teams. Teams will be assigned an application to build (with the session leaders acting as the customer), e.g. Web 2.0 social networking site, or 50-user business GUI application etc. (5 mins)
  3. Groups discuss and argue about what tools, frameworks and libraries are important or not, either to use or avoid, for their project. Groups will write up a chart indicating their consensus on what they think (20 mins)
  4. Groups further narrow down their choices towards what's most/least important by a couple of rounds of voting (15 mins)
  5. Groups now reflect on the previous section. In cases where there was consensus, why was this? In cases where there was uncertainty or disagreement, why was this? (15 mins)
  6. As a whole, retrospect (15 minutes) - what are the common features of the favourites? what are the common features of the least important? what disagreements did you have? why?

On Snowflakes and Architecture (Steve Love) {Slides}

Wed 14:00, 90 mins (Charlbury)

A talk on how architectural decisions in software can influence its design, and affect different aspects of the whole thing, specifically its adaptability, testability, portability and maintainability. The session takes a suspicious look at the traditional layered architecture, and suggests some ways it can be improved upon, resulting in an "architecture" that resembles a snowflake more than it does a cake.

A case-study running throughout will demonstrate the key issues, and also show how each of the "-ility"s above affect each other in sometimes subtle ways.

The main points to be covered will be that component inter-dependency is everything, and managing that is crucial, that portability makes the difference between being able to test software only by running it in its target environment, and being able to unit test it anywhere, and that adaptability can allow you to work on a project when key parts of it are unavailable.

Robots everywhere: the next step after PCs? (Bernhard Merkle) {Slides}

Wed 14:00, 90 mins (Wolvercote)

In January 2007, Microsoft Robotics Studio 1.0 was released. It enables us to easily create robotics applications, simulate them, write own device drivers and even exchange hardware without recoding. Robotics could be the next revolution in IT (after the PC in 80s). In this session we will jump into Microsoft Robotics Studio, see how applications can be build and run them vitrually or in reality. Also real world usages of Robotics Studio are shown.

A Tale of Two Systems (Pete Goodliffe) {Slides}

Wed 16:00, 90 mins (University)

We all want to design excellent code. We try to craft elegant, clear, beautiful software. Sometimes we're sucesful. Sometimes we're not. Often legacy code or company politics conspire to produce grotesque software monstrosities desite our best efforts.

So what can we do to design great software under the pressures of the real world?

This talk will look at some of the characteristics of well-designed software, and will contrast two real life code bases to learn what makes a good software design, and what makes a foul one.

There's little more valuable than real-world experience, and here we will learn from the mistakes and successes of other projects - more pain for less gain. We'll have a bit on fun on the journey, too.

The Customer, their Requirements, and the Developer (Allan Kelly, Liz Sedley) {Slides}

Wed 16:00, 90 mins (Blenheim)

We all know bad requirements when we see them, and we all know what doesn't work, but how can we get good requirements? This session will look at how requirements are gathered and how we can get good requirements.

The session will start with a look at how requirements are traditionally gathered and the different type of software product (shrink wrap, bespoke internal and bespoke external). The audience will then be invited to suggest the best ways of gathering requirements in each environment.

When Good Architecture Goes Bad (Mark Dalgarno) {Slides}

Wed 16:00, 90 mins (Charlbury)

As software evolves its architecture "as-is" deviates from its architecture "as-intended" -- the architecture is said to decay.

Architectural decay can be a problem because:

  • the time, effort and risk in implementing further changes increases
  • the effect of further changes becomes harder to predict
  • further changes typically cause the "as-is" architecture to deviate further from the "as-intended" architecture -- the situation becomes worse.

The session's objectives are:

  1. To explore the effects of architectural decay.
  2. To agree that preventing (or slowing) architectural decay is a "good thing".
  3. To identify possible practices for maintaining architectural integrity and issues around using these practices.
  4. To discuss the business value of work to prevent or slow architectural decay.

This session is suitable for architects, designers, developers, managers and others involved in the development of software systems.

Robot wars: open source vs microsoft (Jan-Klaas Kollhof, Ed Sykes) {Slides}

Wed 16:00, 90 mins (Wolvercote)

In december 2006 microsoft released the first version of their robotics suite. Bill gates has likened the existing robotics market to the early pc market of the 80s. We propose to compare and contrast microsofts offering with alternatives from the open source world.

We would like to present a 90 minute session comparing and contrasting the tools available to the open source and microsoft worlds. The session will be heavy on live examples of the environments available and we will also show some examples of behaviours created in different environments in embodied robots, most likely to be lego nxt robots.

We would also like to run a workshop that would allow people to program some embodied robots, some using microsoft software and some using open source software. The culmination of the workshop would be open source vs microsoft in a game of british bulldog. The rules of british bulldog are simple, one team defends and one team attacks. The defenders must stop the attackers from reaching one side of the arena and do so by touching an attacking robot. Each team gets a chance to attack and the winner is the team that gets the most robots to the other side of the arena.

Although myself and jan will be purchasing our own lego nxt kits in order to create the workshop and presentation we would look to get sponsorship in order to provide enough robots to run the workshop.

Thursday 03 April 2008

Caging the Effects Monster: the next decade's big challenge (Simon Peyton-Jones) KEYNOTE

Thu 09:30, 60 mins (University)

In mainstream programming languages, side effects are part of the fabric of computation: any procedure can cause any side effect, and many procedures are called only for effect. Successful as this programming model has been, I will argue that unrestricted effects have a pervasively pernicious effect on software technology, with consequences in program understanding, specification and verification, testing, and parallelism, all areas of increasing importance. If we want to write more ambitious, reliable, and parallel software, we must use side effects more sparingly, and in a more controlled way.

Functional programming languages take a particularly principled approach to effects, and I believe that is the underlying reason for their increasing popularity. In my talk I will try to give you a visceral feel for what functional programming is like, and how it might contribute to a radical re-think of the whole business of writing programs.

The Selfish Object (Kevlin Henney) {Slides}

Thu 11:00, 90 mins (University)

Instead of focusing on what an object, component or subsystem can use or be given, focus on what the object, component or subsystem wants. In essence, express essential external dependencies by defining specific, narrow, plug-in-style interfaces. Such self-centredness leads to a highly localised, open and testable architectural style, sidestepping the problems of singleton objects or the transitive coupling across layers common in many architectures.

Some programmers have already come across this style in the context of introducing mock objects for testing database dependencies, or the use of dependency injection in the context of specific middleware platforms, or the choice to base a system's extension on plug-ins. However, this session outlines the motivation more broadly than each of these specific instances, explaining why a more object self-centred approach to class design should generally -- not just specifically -- be considered the way to do business with objects. Consistent application of this parameterize-from-above micro-architectural style results in a loosely coupled macro-architecture based on "inversion layers".

The future of concurrency in C++ (Anthony Williams) {Slides}

Thu 11:00, 90 mins (Cherwell)

An introduction to the concurrency features being added to the C++0x standard, and TR2. After a brief introduction to the lower level facilities, such as the memory model, I will discuss the library features, and programming model.

Java Programming in a Multicore World (Angelika Langer)

Thu 11:00, 90 mins (Blenheim)

With the increasing availability and use of multicore processors Java developers need to acquire some understanding of the Java memory model. This is because multithread applications that work nicely on a songle-core processor might exhibit "inexplicable" deficiencies when running on a multicore processor platform. The reason may be differences in the caching strategies applied by different processors. In order to illustrate the issues this tutorial explains the Java features for multithread programming. Key topics include: old and new locks, volatile and atomic variables, memory model, visibility and reordering issues, lock-free programming.

  • Audience: Java developers who develop Java applications with parallel or concurrent processing using multiple threads and developers who are generally interested in Java multithread programming.
  • Level: intermediate
  • Prerequisite: Basic knowledge of Java and concurrent programming

Product Managers - What do they do and how can I work with them? (Aviv Handler)

Thu 11:00, 45 mins (Charlbury)

The title of "Product Manager" can have a different meaning:

  • In different companies
  • To different departments
  • In different industries

Here we will examine:

  • What the role of a product manager is and how they contribute to the well being of a technology company
  • How product managers can work productively with developers to product scalable high quality offerings
  • Why those with a technology background make good product managers
  • How to work with product management, or even to become one

Erlang - Concurrent programming with pure message passing (Joe Armstrong)

Thu 11:00, 90 mins (Wolvercote)

The world is concurrent, yet most of the programming languages we use to interact with the world are sequential.

This makes programming artificially difficult.

Conventional programming languages use abstractions like shared memory and transaction consistency that violate the laws of physics. Normally this doesn't matter, but in the presence of errors, it is impossible to write correct software based on such abstractions.

Erlang uses no such assumptions. The Erlang world is one of isolated processes evaluating functions which exchange data through messages. It combines ideas from the world of functional programming with constructs for light-weight concurrency and adds a dash of error-detection and recovery all of it's own.

This talk shows how it is possible to build highly concurrent systems without using shared memory and locks resulting in systems that are reliable, scalable and easy to understand.

Starting and Running a MicroISV (Dave Vest) {Slides}

Thu 11:45, 45 mins (Charlbury)

Running a small company all by yourself is tough. From the initial writing of the software, for which there are no guarantees anyone will pay for, to the day to day administrative annoyances like paying the bills to keeping the accounts up to date. Moving from a large team development environment where you can rely on people to write the help file, test the product, do sales and marketing, update the web site, respond to user requests, create graphics, manage development to performing all those tasks yourself can be very challenging. Not to mention the financial pressures and pressures from friends and relatives who just don't understand why you've given up a lucrative job for a life of penny pinching and far longer hours.

However, nothing beats the thrill of seeing a large order come into your inbox or seeing your product mentioned in the newspaper. It's your baby, and it's beautiful! In fact, probably the greatest problem you'll face is ever going back to working for someone else.

Toward a Common Intuition and Reusable Testing Methodology (John Lakos)

Thu 14:00, 90 mins (University)

The C++ language provides a rich collection of syntactic constructs, which can be composed in myriad ways to satisfy just about any practical real-world software need. This overwhelming design space, however, does present a challenge. Without a comprehensive model for design, we would be unable to avoid admitting gratuitous variations and inconsistencies, thereby substantially reducing the effectiveness of our development process as measured by the interoperability of our resulting software components (and our ability to understand, test, and maintain them). In this talk we identify several important design concepts that we (Bloomberg LP) use routinely to characterize aspects of our large-scale, performance-critical C++ software (of which we'll see some examples). We show how these concepts guide the design of our classes to conform to a relatively small hierarchy of categories -- each having established properties -- that provide both context and vocabulary, leading to enhanced understandability. Finally, we show how this architectural guidance can result in reusable testing strategies (that exploit core functionality of the class under test), thereby accelerating the development of thorough (unit) test suites.

Adobe Source Libraries, Overview and Philosophy (Sean Parent) {Slides}

Thu 14:00, 180 mins (Cherwell)

The Adobe Source Libraries are a collection of high quality C++ components created as part of Adobe's Software Technology Lab's research into better ways to develop applications which are robust, powerful, and fast. In this talk we'll take a look at several of the libraries and the ideas behind them including:

  • forest library - a container for hierarchical data-structures
  • move library - eliminating unnecessary copies
  • copy-on-write library - how you can build better multiple-undo into your application
  • poly library - using generic programming with runtime polymorphism
  • layout library - creating good looking human interfaces in a multi-platform, many language world
  • property model library - creating self-functioning user interfaces

Bring your questions about ASL - I'll take the time to answer as many as I can.

Introduction to Java Native Interface programming (Alison Lloyd) {Slides}

Thu 14:00, 90 mins (Blenheim)

JNI seems to have a reputation as complex and best avoided. In fact, it provides a very useful mechanism to support hardware in Java, and is actually pretty simple to use. In this talk I will introduce JNI, examining the pros and cons of its use, and demonstrate the creation of a simple wrapper class that adds some hardware support to a Java system via a Windows DLL.

The Simplicity Workout (Kevlin Henney, Peter Sommerlad, Giovanni Asproni) {Slides}

Thu 14:00, 90 mins (Charlbury)

This session can be considered a continuation of last year's "Simple Code" workshop. We are interested in exploring simplicity at all levels, software features, requirements, design, code, etc.

The overall aim is to give the attendees some tools to help them in recognising and appreciating simplicity in software when they see it, and also to be able to produce better software with the appropriate amount of complexity--software that is as simple as possible but not simpler.

This intensive workshop will be split in two distinct parts.

The first one will be a "simplicity admiration" one in which the attendees will have an opportunity to see and discuss Examples of simple software. The goals of this part are:

  1. higher valuation of simple code
  2. try to figure out what makes software "beautifully simple"
  3. continue work on Simplicity Manifesto

The second part will be a “simplifying workout”. It will consist of examples of code to be simplified: (show unnecessary complex code and discuss/work out on how to refactor/simplify the code, collect results, etc.)

The goal of this part is to practice simplifying/refactoring, and learn simplification.

A Taste of Haskell (Simon Peyton-Jones)

Thu 14:00, 180 mins (Wolvercote)

Haskell is the world's leading purely functional programming language that offers a radical and elegant attack on the whole business of writing programs. In the last two or three years there has been an explosion of interest in Haskell, and it is now being used for a bewildering variety of applications.

In this tutorial, I will try to show you why programming in Haskell is such fun, and how it makes you think about programming in a new way.

I'm going to use xmonad ( as my running example; it's an X11 window manager written entirely in 500 lines of Haskell. Based on xmonad I will show you how to

  • write functional programs
  • test them using QuickCheck
  • write imperative programs
  • call foreign functions
  • use Haskell for scripting applications

I won't assume you know any functional programming at all, but I will assume that you are an experienced professional programmer, so I will move along quite briskly.

I first delivered this tutorial at OSCON 2007, but I'll encourage lots of questions as we go along, so it may turn out quite differently!

Memory Allocation: Either Love it or Hate It (Or Think It's Just OK). (Andrei Alexandrescu) {Slides}

Thu 16:00, 90 mins (University)

The memory allocation problem has been hashed for so long, many people consider it either solved or unsolvable. After a thorough overview of the field, this talk gives sound, no-nonsense advice to anyone who's ever cared about the costs of allocation.

Them threads, them threads, them useless threads (Russel Winder) {Slides}

Thu 16:00, 90 mins (Charlbury)

The next C++ standard will introduce an official threads model -- based on, but not identical to, pthreads. Java has had an official threads model, with strong support, from the outset. It has taken C++ a long time to catch up -- has Java envy finally got to it? The question is really though whether introducing threads is a positive or retrograde step.

The problem is that parallelism is coming. Although parallelism has been coming technology for the 30 years, it is now actually really here. True, the high-performance computing (HPC) arena has been a parallel one for many years. True also that servers have been parallel for many years. HPC is a very small community that has standardized on OpenMP and MPI for managing parallelism. Servers generally try to operate with threads to provide access to the parallelism but relies on the parallel threads having no inter-thread communication, so that there is no synchronization requirement. The point is though that they day of the 80-core chip is nigh. Instead of 4 or 8 processors on a workstation, there will be 160, 320. On a server, which already has on the scale of 64 or 128 processors, they will effectively have thousands of processors.

This is a new world, but will it be brave? Will the software community cling desperately to threads as the tool of concurrency, and fail dismally to have the vast majority of programmers actually be competant at writing parallel programs, or will it display bravery and look at new paradigms of computation that integrally encompass parallelism in a way that the average programmer can handle.

Although Java has a single model of object locks, monitors, synchronized statements and the whole infrastructure of concurrency reified directly in the language, very few programmers can actually write good concurrent software. C++ has always had the problem of there being many models of concurrency. The new standard is supposed to solve this, but will it? The suspicion is not since Java has a problem and C++ is falling into the same pit.

The problem is the level of abstraction. Shared data, synchronization, etc. are too low a level for the average programmer to work. Libraries such as java.util.concurrent show that by raising the level of concurrency management for applications programs, less than genius level programmers can get it right. C++ would do well to observe this lesson, and sooner rather than later.

On the other hand why not take a lesson from Erlang and do the whole "declarative thing". Instead of trying to manage things in an imperative way, grasp the opportunity that multicore processors are giving and change paradigm. Be declarative.

As the above makes clear that this session will be a review of concurrency techniques in an increasingly parallel world and will compare the techniques of C++, Java and Scala versus those of Haskell and Erlang.

Enterprise Java 5.0 Vertical Slice: Moving data from JavaFX to JPA and Back Again (Peter Pilgrim)

Thu 16:00, 90 mins (Blenheim)

This session will cover software development with the Java Persistence API 1.0, which is part of the EJB 3.0. Many developers, who build applications, are working daily on J2EE. This is largely because their companies have older application server in their production environment. J2EE requires Java SDK 1.4, however the latest Java EE 5.0 mandates the Java 5, because of the use of annotation. This talk will introduce key concepts of JPA 1.0 and how to use the annotations. It will describe how core data models are built. The talk will touch lastly on interfacing the core model to a stateless session EJB. The second part of the talk is about implementing EJB 3 stateless session bean that calls on the data model. I will demonstrate a Java FX front-end that calls the EJB 3 service point. This will be a proof-of-concept for financial services IT developers contemplating the move from Java Swing to Java FX and also upgrading from J2EE 1.4 to Java EE 5.0.

The application server for this talk will be GlassFish 2.0 version 58

Just A Minute (Ewan Milne)

Thu 18:00, 45 mins (University)

Join Ewan and a team of ACCU irregulars as they play "Just a Minute", an entirely new and original panel game. The object of the game is for panellists to talk for just a minute on a given subject without repetition, hesitation or deviation. With a format shamelessly ripped off by the BBC 40 years ago, sit back and enjoy as the conference's biggest chatterbox is revealed.

Friday 04 April 2008

Fri 07:30, 90 mins (Wolvercote)

Qt is the world's leading cross-platform application development frameworks. In this seminar, you'll get a quick overview of what Qt is and which technologies will be introduced in the next version (4.4). This session will be accompanied by a light continental breakfast, served with a bowl of demos and completed with a side dish of live coding for your geeky enjoyment.

May You Live Interesting Times (Andrei Alexandrescu) KEYNOTE

Fri 09:30, 60 mins (University)

Andrei takes a step away from coding and discusses the state of affairs in software research and development at large, education, crises, opportunities, and hope.

Managers: What are they good for? (Allan Kelly) {Slides}

Fri 11:00, 90 mins (University)

This is a presentation for developers who would like to know what managers do all day; and for managers who wonder what they should be doing.

On the face of it you don't need managers, put a bunch of good developers in a room and they will do the right thing. However it is often management that makes the difference between success and failure. But what do managers actually do? And why is good management so hard to find?

In this presentation Allan will look at these questions, discuss the different types of manager we find in a development organization and make some suggestions -- with the help of the audience -- about what a good manager should be doing.

C++ Refactoring and TDD with Eclipse CDT (Peter Sommerlad) {Slides}

Fri 11:00, 90 mins (Cherwell)

This talk demonstrates the Refactoring capabilties the IFS Institute for Software created as an extension to Eclipse CDT 4.0. It is planned to integrate these Refactorings into CDT with the Ganymede release of the Eclipse projects. The CDT Refactoring plug-in provides various automated Refactorings, such as

  • Declare Function: create a function declaration in a header file
  • Implement Function: create a function definition in a source file
  • Extract Function/Method: create a new function definition from a selected sequence of statements and replace the sequence by a call

Refactoring and Unit Testing are the base for Test-Driven Development in C++ which will be used to demonstrate the features of our plug-ins.

A glimpse of other Refactoring Eclipse plug-ins developed by IFS and its students will be given (Ruby, Python, Javascript, PHP, groovy)

Software Packaging with RPM (Schalk Cronje) {Slides}

Fri 11:00, 90 mins (Blenheim)

The Red Hat Package Manager is used widely on a number of Linux distributions. It simplifies distribution of binary images, and the management of dependencies. It also offers a very flexible and powerful way of packaging up software. For many people writing spec files is still a dark art and as such still revert to unmanageable techniques for deploying software on RPM-based Linux distributions. Having worked with RPMs in a variety of projects and system administration, I have seen that with a little bit of help and correct guidance it is very easy for someone to get up to speed.. Unfortunately with online documentation scarce and incomplete it is not always easy for someone to be self-taught on this subject.

In this tutorial-style presentation I'll cover:

  • Usage of the command-line tools to management packages using rpm, yum and urpmi.
  • How to build and create new packages using rpmbuild
  • The finer details of writing spec files for open-source and closed-source software.
  • How to invoke rpmbuild from a GNU Make and safely re-enter the same Makefile
  • Bad smells in spec files

IronPython: Dynamic Languages on .NET (Michael Foord) {Slides}

Fri 11:00, 90 mins (Charlbury)

IronPython is the first of a new wave of dynamic languages for the .NET framework.

Dynamic languages are gaining in popularity, and with IronPython and the DLR Microsoft are committed to making the CLR a good platform for dynamic languages. Not only this, but they can also be used with the new platform: Silverlight the browser plugin.

Dynamic languages increase developer choice, enable new programming paradigms for the .NET framework, and provide a readymade scripting engine solution for .NET applications.

In this talk I will explore the following topics:

  • Why dynamic languages?
  • The story of IronPython and the DLR
  • IronPython on .NET (interacting with the CLR)
  • Multiple programming paradigms on .NET (functional, procedural, OOP, metaprogramming)
  • Dynamic languages on Silverlight
  • Embedding IronPython in .NET applications

Functional Programming Matters (Russel Winder) {Slides}

Fri 11:00, 90 mins (Wolvercote)

In the 1990s object-oriented programming took the mantle as the successor of structured programming and created a hegemony of thought enshrined in C++, Java, Python, Ruby and Groovy. Functional programming -- the poster child of the constructivists and theoreticians -- was brushed aside as an irrelevance. Moreover, unit testing and test-driven development have enshrined experimentalism as the dominant mind-set.

OK, enough of the philosophical pretensions, what is the issue? In a computing world that is increasingly a highly parallel world, object-oriented technology, indeed the whole of imperative technology, with its reliance on threads and explicit manual control is falling apart. Even the HPC community that has standardized on OpenMP and MPI as concurrency (and hence parallelism) tools has indicated that there are problems.

Meanwhile, pragmatic (as opposed to academic) functional programming has actually thrived, albeit as a dark corner niche. Haskell has been around nearly 10 years and Erlang even longer. Given that 10 years is the normal gestation period of a programming language…

Although Haskell has few seriously major applications written in it (Darcs and Perl 6 are possible the most well known), it has been chugging along making itself more and more relevant to the world at large. Ericsson has been using Erlang for all its telecoms switch software for many years, this is definitely real world! Erlang in particular has a new (to imperative programmers anyway) view of concurrency -- though anyone with a knowledge of Occam could successfully argue against this claim.

The point here is that the declarative, stateless paradigm of functional programming has a novel approach to concurrency and parallelism that means it controls it far more easily that imperative languages relying on threads.

The question is whether there are abstractions possible for the object-oriented languages. The answer is almost certainly yes, and they will almost certainly come from the functional languages. Or it may be that functional programming is the natural successor to object-orientation, and its time is nigh.

This session will be a survey of the problems and a review of the various solutions.

Designing Maintainability, and Adaptability by Software Engineering: a Quantified Approach (Tom Gilb) {Slides}

Fri 14:00, 90 mins (University)

Software system maintenance costs are a substantial part of the life cycle costs. They can easily steal all available effort away from new development. I believe that this is because maintainability is as good as never systematically engineered into the software. Our so-called software architects bear a primary responsibility for this, but they do not engineer to targets. They just throw in customs and habits that seem appropriate.

We need to define our maintainability requirements quantitatively, set investment targets that will pay off, pursue long-term engineered improvement of the systems, and then ‘architect’ and ‘engineer’ the resulting system. Other disciplines within systems engineering may already in principle understand this discipline, some may not understand it, some may simply not apply the engineering understanding that is out there

Fri 14:00, 45 mins (Cherwell)

It would appear to be common knowledge that doing a complete rewrite of an existing application is a bad idea. Yet many developers still want to do it. Once an application has reached a certain point in its life cycle, a rewrite often looks like the only way out.

This session looks at the motivation for a rewrite and highlights the risks of such a decision, both from a technical point of view and considering what it could mean for your business. We will also be discussing alternative strategies and why your situation may not be as hopeless as you think it is. Rounding things off will be a list of tips on how to avoid getting into the same situation again.

Building Lessons (Alan Griffiths) {Slides}

Fri 14:00, 90 mins (Blenheim)

On many projects we've encountered and fixed problems with building the system. Both developing code and releasing a version of the resulting system effectively depend upon the ability to identify versions of the codebase and reliably produce the system from them. Despite this many organisations give scant attention to how the code is built and deployed.

Since the last conference both speakers have taken contracts where the primary focus of their work was resolving issues with building the system - which seems like a good excuse for comparing notes and sharing experiences. This session relates some of the problems we've encountered in this area and considers the effectiveness of attempts to solve them.

Grafting Functional Support on Top of an Imperative Language (Andrei Alexandrescu) {Slides}

Fri 14:00, 90 mins (Wolvercote)

This talk presents how the D 2.0 programming language incorporates functional programming features, including pure functions, closures, and transitive invariance.

Web Content Management With Documentum (Astrid Osborn)

Fri 14:00, 90 mins (Charlbury)

This talk will take a look at how to take largely unstructured information and transform it into a usable/publishable form.

Is the Project Manager an Endangered Species? (Roman Pichler) {Slides}

Fri 14:45, 45 mins (Cherwell)

With the rapid spread of agile methods such as Scrum, corporations face a dramatic change: A new breed is emerging that challenges the traditional project and product manager roles. The new species is called Product Owner. The product owner leads and guides a Scrum project. He decides which requirements are implemented and when the software is shipped. Having a strong, empowered product owner is a key success factor for Scrum projects -- just like a strong, empowered team is. This talk provides insights into being an effective product owner. It also discusses how project management responsibilities are handled in Scrum and strategies for helping project managers transitioning into the new agile world.

Know Your Units (Kevlin Henney) {Slides}

Fri 16:00, 90 mins (University)

These days testing is considered sexy for programmers. Who'd have thought it? But there is a lot more to effective programmer testing than the fashionable donning of a unit-testing framework: effective unit testing involves (a lot) more than knowledge of assertion syntax.

Testing represents a form of communication and, as such, it offers multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of what forms of feedback and communication are offered by tests, and what styles encourage or discourage such qualities. Unit testing can highlight coupling problems, functional defects, problematic programming practices, awkward programmatic interfaces, overly procedural objects, overly object-like functions, unclear requirements, poor integration culture, development process problems and so on. However, not everyone appreciates that problems with unit testing tend to be a consequence of these deeper problems, and so they aim to fix or criticise symptoms rather than root causes, thus missing a valuable opportunity for improvement and learning.

While there is certainly more to testing than unit testing, and more to a well-rounded approach to development than just testing, a failure to appreciate the role and practice of unit testing can lead to disappoint or a skewed notion of testing as a programmer's responsibility. This session aims to look at some issues, examples and counterexamples that help to highlight some of the problems and offer some solutions.

C++/CLI - Why, oh why? (Seb Rose) {Slides}

Fri 16:00, 90 mins (Cherwell)

Focussing on interoperation between .NET assemblies and 'legacy' C++ code we will explore why C++/CLI was invented and what it is for. This session will introduce a number of (highly stylised and simplified) 'case studies' to explore some of the applications of this new language/binding. Specifically, we will look at extending MFC application with .NET assemblies and using legacy code from .NET applications. We will briefly compare C++/CLI to other popular .NET languages in the context of interoperation with legacy code. Particular attention will be paid to what is going on 'under the hood' to give a feel for some of the issues that must be considered when designing in C++/CLI.

To distribute or not to distribute or How to know your DVCS from your CVSC (Jim Hague, Russel Winder) {Slides}

Fri 16:00, 90 mins (Blenheim)

In the beginning was the card deck. And lo, the card deck fell to floor, and man knew more or less immediately that source code control systems were a damn good idea.

SCCS and RCS were possible the first actively viable source code management (SCM) systems, but they were quickly overtaken by CVS, which rapidly became a de facto standard. ClearCase and Perforce (amongst others) showed that not only were there things CVS was missing but also that money could be made from SCM systems.

Subversion was developed to cure all the ills of CVS, and, after various hiccups over which database to use, it does seen to have replaced CVS as the de facto standard. However, there is an issue. There is one and only one repository for any particular code base. This means that unless you can connect to the repository there are a whole set of actions that are not possible, e.g. committing changes. This is possibly not an issue in a centralized organization, especially when there are security issues at the network boundary. However, the world is an increasingly both an agile and a distributed place. Frequent commits and distributed working are the zeitgeist, and the laptop has freed programmers not only from mains electricity, but also from the network.

And then there came the distributed SCM systems, where everybody can have their own branch on their own local disc and merging branches is as important an issue as committing changes. Leading the charge was Sun Teamware, and its commercial offspring Bitkeeper. The Free and Open Source (FOSS) world, where distributed working is prevalent, saw first Arch, and more recently Bazaar, Mercurial, Monotone, Darcs, SVK and Git.

So what's the big deal, isn't this just another set of SCM systems vying for market share? In a sense, yes it is. However, there is a big difference and that is that centralized and distributed approaches to SCM involve very different workflows and work practices.

Do not be fooled by the apparent simplicity of the problem, it is not so straightforward: Bazaar aims to replace Subversion as a centralized SCM system as well as working as a distributed SCM system!

In this session, we shall compare and contrast centralized working (using Subversion and Perforce (?) as examples) versus using distributed working (using Bazaar and Git (?) as examples). The format will be something like a balloon debate, the idea will be for the representatives of the tools to give a very short presentation, to take questions from the floor and then to vote on removal of one tool from the set being considered. Then more rounds of short comments, questions and votes till there is a survivor.

Using Python for Sysadmin Programming (John Pinner) {Slides}

Fri 16:00, 90 mins (Charlbury)

The philosophy of Unix sysadmin was to have lots of small tools, each of which did one job well, and to provide the mechanisms to join them together to perform larger tasks. The glue joining them together was the Bourne shell. Generations of Unix system programmers used Bourne with the classic utilities like awk, sed, find and tar to look after their systems.

Over the years the development of Unix-like systems such as Linux has seen this philosophy diluted with the advent of the bloated bash shell and utilities, although based on the original Unix tools, with ever more complex options.

An alternative I have tried is using Python. Python is a compact progarmming language, augmented with a large number of modules which extend its capabilites. In this respect Python is similar in philosophy to classic Unix thinking, with the added benefit of being a modern high level and object-oriented language.

In this talk, which will be in a tutorial style, I will describe some of Python's capabilities in a sysadmin context, with code examples, and discuss its benefits. One of the greatest is that Python is multi-platform, being available on Unix, Windows, Linux and Mac. For example it is possible to have one backup script for use across all platforms, and to restore your backups across platforms.

Indexed Programming (Jeremy Gibbons) {Slides}

Fri 16:00, 90 mins (Wolvercote)

Indexed programming involves parametrizing types by values. This allows programs explicitly to capture data invariants in the types; proving that invariants are maintained then becomes a matter of type-checking. The best-known theory of types parametrized by values is dependent typing, which is richly expressive but neither easily nor widely implemented. Recent developments in modern programming languages - specifically, Haskell's generalized algebraic datatypes - show how to achieve a kind of lightweight dependently-typed programming, by reflecting the value indices at the type level. Only minor changes to the language are required, but major benefits in expressiveness are obtained. Moreover, the same techniques are applicable to the generics provided in more mainstream languages such as Java and C#.

Applications of indexed programming include type-safe reflection, data structure shapes and invariants, safety properties of stateful components, and proof-carrying code. This tutorial presents the ideas behind indexed programming, shows a variety of compelling examples, and explains how to apply the techniques using Java generics. It builds on recent research at Oxford, part of which inspired a tutorial presented at OOPSLA 2005. It will contribute to the FP stream at ACCU.

Participants should be fluent OO programmers, ideally but not necessarily familiar with modern functional programming as in Haskell or ML. Some knowledge of Java or C# generics or C++ templates will be helpful, but not essential. Participants will complete this tutorial having understood the principles of indexed programming; explored a variety of examples of their use; and learnt how to transfer the techniques to mainstream languages.

Saturday 05 April 2008

Seven Deadly Sins of Debugging (Roger Orr) KEYNOTE {Slides}

Sat 09:30, 60 mins (University)

Debugging is a necessary evil, but why do some people seem to be much better at it than others?

While innate characteristics play some part in this, a large part of good debugging can be learned - but there are things both to learn and to unlearn.

In this presentation we will look at seven characteristics that keep us unskilled at finding and fixing faults in our programs: inattention, pride, naivety, anger, sloth, blame and vagueness.

Overcoming these problems will help us fight more successfully against the bugs we encounter.

Five practical solutions to Agile myths (James Coplien) {Slides}

Sat 11:00, 90 mins (University)

The results are in... Many ideas in the Agile canon and folklore can actually decrease your velocity or can slowly posion your code. Other contemporary fads have well-known pitfalls that have been forgotten since their last round of popularity. In this talk I look at five of these common practices, why they are harmful, and how to avoid their pitfalls:

  • TDD: Use lightweight architecture and an appropriate scope of testing to avoid architecture rot, high test maintenance cost, and usability problems.
  • YAGNI: Use Case Slices and lightweight architecture can help avoid being blind-sided On-Site Customer: Add a product owner to avoid burning out both the customer and the team.
  • User Stories: Instead of deferring detailed scenario development to your development during TDD, use Use Cases to bring the analysis out to the person who matters: the market constituency
  • Domain-Specific Languages: Take the value from the analysis and run with it; sometimes, building a domain engineering environment buys you only cost and headaches These remedies work well with each other.

The complete guide to C++0x (Alisdair Meredith)

Sat 11:00, 90 mins (Cherwell)

A lightning tour of all the new and updated features in the pending revision to the C++ standard. This will cover everything from Concepts and move semantics through to reference collapsing and simplified use of angle brackets. Every revision to Core or Library will be covered, but in a minimum of detail, to see the full breadth of the new language.

The Model Student: Some Simple Exercises in Computer Simulation (Richard Harris)

Sat 14:00, 90 mins (Blenheim)

The diet of the modern programmer is a rich mix of databases, web pages and network protocols, with a soupcon of multi-threading to taste. Undoubtedly nutritious, it has brought the field of computing from its first faltering steps into the public consciousness over half a century ago to the great strides into everyone's daily life that we have witnessed in recent years. Nevertheless, the spirit occasionally yearns for the humble fare of yesteryear, when resources were limited and programming was chiefly concerned with simple programs to solve scientific puzzles. In this session, we shall take a look at a few simple puzzles inspired by some of the great problems of the modern age, such as why the lead on my headphones keeps getting tangled up. Using a combination of computer simulation and basic mathematics we shall endeavour to shed some light on these conundrums, hopefully learning a few handy tricks along the way.

Researching a Problem and Getting Meaningful Results: A case study (Alan Lenton)

Sat 11:00, 90 mins (Charlbury)

What do you do when experience and gut feeling makes you sure that something you are working on in its early stages is not going to result in an acceptable customer experience? Management will want hard figures to convince it that you should be allowed to change things at a cost in time and hard cash..

Using a case study drawn from the computer games industry, this talk looks at how you first quantify quality issues, and then how you design and carry out tests to deliver figures that will make your point unambiguously.

Is FP for me? (Hubert Matthews) {Slides}

Sat 11:00, 90 mins (Wolvercote)

So you've decided to learn something about functional programming (FP). After the excitement of learning something new subsides you will no doubt have a multitude of questions such as: Is functional programming for me? How will I be able to use it? Should I build my next web site using it? Do I need a functional language or can I use what I know already? What is FP's sweet spot and where are there better alternatives? How does FP relate to current trends in computing such as multicore or distributed systems? Who is using this stuff for real? Is this a passing fad or something longer lasting?

This talk seeks to place FP in a wider context and discusses these and similar questions.

Organizational Patterns: The Foundations of Agile (James Coplien) {Slides}

Sat 14:00, 90 mins (University)

Scrum author Mike Beedle said of the Organizational Patterns book, "Organizational Patterns is perhaps the first documentation that ever existed on true Agile development. No one, to my knowledge, had done so before. (Not Scrum, which started in 1993, nor XP which started much later.) So: what important concepts are you missing from your Agile practices?

Organizational patterns describe organizational structures that lay the foundation for Agile competence and which lead to the insights for Agile excellence that takes you far beyond the basic out-of-the-box methods. Both Scrum and XP trace their roots to these patterns, each one having built on a subset of them to focus on project management and developer-centric work respectively. Come and learn a bit about what the other 75% of the good stuff is: In this talk, I present the "Top 10" patterns -- those that correlate most strongly to organizational success.


What are patterns and organizational patterns?

The Top Ten:

  1. Unity of Purpose
  2. Engage Customers
  3. Domain Expertise in Roles
  4. Architect Controls Product
  5. Distribute Work Evenly
  6. Function Owner and Component Owner
  7. Mercenary Analyst
  8. Architect Also Implements
  9. Firewalls
  10. Developer Controls Process

C++ for Embedded Systems (Detlef Vollmann) {Slides}

Sat 14:00, 90 mins (Cherwell)

Embedded software is different: it often involves hard real-time constraints and very limited memory. But the challenges for embedded systems are even higher: they must be very reliable (99.9% uptime often is not good enough) and need to work with a variety of different memory types (standard RAM, EEPROM, Flash, buffered RAM, …) and other specific devices. Another frequent design problem is the different kinds of processing tasks: interrupt handling, hardware control, application processes - all interconnected by a selection of different communication mechanisms. But embedded systems also have a big advantage to "normal" applications: In general, you know exactly in advance what is going to run on your hardware, and you can control it all.

Traditionally, embedded systems were programmed in assembler or C. And where systems were programmed in C++, just a specific subset of C++ was used. And still many designers believe that objects in heavily constrained systems (e.g. 8-bit processors) have no role. Nothing could be farther from the truth. Given the correct tools, object oriented systems can perform better with tight resources than traditionally designed systems. As a rich multi-paradigm programming language, C++ is such a tool that combines the full power of object-oriented design and programming with a maximum of performance while still allowing for the strict control necessary e.g. for hard real-time requirements.

This talk will present and discuss various techniques for designing and implementing typical embedded systems leveraging object-oriented mechanisms while minimizing resource consumption. As implementation language C++ will be used and real-word examples will be shown.

Intended audience: This talk is for programmers and designers of embedded systems as well as for project managers responsible for the development of embedded systems. A good working knowledge of ISO C++ and a background of embedded systems is helpful, but not required.

Getting a Buy-In to a Secure Development Process (André Marien, Bart De Win, Johan Peeters) {Slides}

Sat 11:00, 90 mins (Blenheim)

Session Objectives: This session briefly reviews a few of the secure development processes that have emerged in the last couple of years and examines the effectiveness of the measures proposed. It aims to reach consensus amongst the participants on simple, actionable advice for improving the security of applications delivered by development teams.

Session Overview: The insecurity of software application is at best embarrassing, at worst a threat to a society that increasingly relies on software. A number of organizations are attempting to stem the tide of software vulnerabilities by adding activities to the software development life cycle that focus on security aspects. This session briefly reviews a few of these secure development processes and then examines the effectiveness of the measures proposed.

The session begins with a very brief presentation of three secure development processes:

  • Microsoft's SDL
  • Cigital's touchpoints process

The presentation focuses on the core ideas and practices of the respective processes. These are debated in affinity groups: testers, architects, project managers and programmers. People are encouraged in this part of the session to narrowly focus their attention on the vantage point of the function they choose when they join an affinity group in order to ensure that we examine the proposed measures from all perspectives. Each group is requested to select 2 or 3 measures that they would like to adopt in their team and provide a plan for their introduction. These proposals are then subjected to critical scrutiny by the other teams in bi-lateral discussions, i.e. teams discuss in pairs.

Proposals are subsequently refined. In this phase, the functional vantage point of the affinity group is relaxed. Participants are explicitly encouraged to modify the elements of the existing processes as they see fit and/or to add others. The resulting proposals are then taken to a plenary session.

Talking 'bout Code Generation (Nicola Musatti) {Slides}

Sat 14:00, 90 mins (Charlbury)

Code generation is a very effective tool that may help increase the productivity of a development team by automating the most repetitive coding activities. However the notion of programs that write other programs sometimes scares off programmers that are perfectly capable of applying these techniques. The aim of this presentation is to show that writing code generators is easy, effective and rewarding.

A Python program that generates portions of a C++ object/relational mapping from the SQL statements that describe a database will provide the motivation to explore the architecture of a code generator, illustrate the techniques that were employed and discuss alternative approaches.

We shall cover the use of parsers and parser generators to collect information. In this part of the presentation the ease with which parsers can be written with the appropriate tools will be stressed over language theory which will only be mentioned to warn about potential pitfalls.

The use of an internal representation on which to perform transformations will be briefly touched, before describing how a templating engine, such as those commonly used in web development, can help ensure that the prototype code on which generation is based may be easily modified.

Code generation will also be compared with other techniques; from the use of reflection, which may help avoid code generation altogether, to template metaprogramming, which in a way is a form of code generation. Attendees should have some programming experience, but knowledge of specific languages is not required.

Performance and Genericity: the forgotten power of Lisp (Didier Verna) {Slides}

Sat 14:00, 90 mins (Wolvercote)

Lisp is one of the eldest languages around, and probably still is the most versatile of them. In our current times where there seem to be a regain of interest for dynamic and functional programming, many of those recent languages (Ruby to name one) acknowledge the fact that they were inspired by Lisp, but not quite as powerful.

So why is it that so many people seem to acknowledge the power of Lisp but so few of us are actually using it? Two important reasons are that people either still think it is slow, or think that being so old, it must be dead, so they simply have forgotten all about it.

The purpose of this session of twofold: first we want to remind people of the power of Lisp, and second, we want to break the myth of slowness. In a first step, we illustrate the expressive power of Lisp by showing how straightforward it is to implement binary methods, a concept otherwise difficult to reach in traditionnal OO languages. This will allow us to provide a "guided-tour" of some of the powerful features of Common Lisp: CLOS (the Object System) and its multiple-dispatch paradigm, the CLOS MOP (the Meta-Object Protocol) and it's ability to let us rewrite new, specialized, objet-systems for our own purpose, and finally the Common Lisp particular package system.

In a second step, we present a recent research demonstrating that Lisp can run as fast as C, given that it is properly typed and optimized. This is done by analyzing the behavior and performance of pixel access and arithmetic operations in equivalent Lisp and C code for some simple image processing algorithms.

State Of The Practice(Tom Gilb, James Coplien, Hubert Matthews, Russel Winder) PANEL

Sat 16:00, 60 mins (University)

We keep talking about new languages, new technologies, new processes, etc., however there are many teams out there which lack basic configuration management skills, don't write any tests, and don't know how to design and write proper code. Are we barking at the right tree?
The panellists will express their opinions and answer questions from the audience.