Preconference
Fearless Change: Patterns for Introducing New Ideas (Linda Rising)
360 mins
We attend conferences or read books and articles discover new ideas we want to bring into their organizations but we often struggle when trying to implement those changes. Unfortunately, those introducing change are not always welcomed with open arms. Linda Rising offers proven change management strategies to help you become a more successful agent of change in your organization. Learn how to plant effective seeds of change, and what forces in your organization drive or block change. In addition to using these approaches to change your organization, you can use them to become a more effective person. Come and discuss your organizational and personal change challenges. Linda shows how the lessons from her book, Fearless Change: Patterns for Introducing New Ideas, can help you succeed. Learn how to overcome adversity to change and to celebrate your improvement successes along with your organization's new found practices.
Growing Object-Oriented Software, Guided by Tests (Steve Freeman, Nat Pryce)
360 mins
Test-Driven Development (TDD) is a deceptively simple idea: write the tests for your code before writing the code itself. We say "deceptively simple" because this reversal fundamentally changes the role of testing in the development process. The tests are now about helping the team to understand the features that the users need and delivering those features reliably and predictably. When followed to its conclusions, TDD changes the way we develop software and, in our experience, hugely improves the quality of the systems we build.
This advanced tutorial is for developers who have started with Test-Driven Development and are looking for deeper understanding. We will show how TDD fits into the whole development lifecycle, with an extended example started from scratch.
We will cover topics such as:
- What's the point of Test-Driven Development
- Kick-starting the TDD lifecycle
- Growing features test-first
- Maintaining the TDD lifecycle
- Object-oriented design with Mock Objects
- Working with third-party code
- Learning to listen to the tests
- Testing asynchronous code
Up and Running with C++0x (Alisdair Meredith)
360 mins
Summary:
This tutorial will break into three packed sessions. The first will take a look at the new standard memory model, support for concurrent execution and atomic operations. The second will take a look at designing new interfaces in code, highlighting rvalue references, variadic templates and lambda expressions. Examples will focus on how these features drive the new thread library, rounding out the concurrency support. The final session will take a deeper look at templates, with a major focus on concepts, introducing the new containers, iterators and algorithms library to provide examples. By the end of the day the attendee will be familiar with the major new language features and a large part of the library.
Prequisites: A good knowledge of existing C++ language and library, a passing knowledge of TR1 would help.
Compilers will be listed nearer the time (session 2 would use a mix of GCC 4.3 and VS2010 CTP, session 3 requires concept GCC, thread libraray via Boost or Just Software. Session 1 is mostly theory - but we expect a broader range of support before conference time) Description:
The goal of this tutorial is to teach the major new features of the new C++ standard. These are seen to be (i) concurrency support (ii) concepts (iii) features for better [code] interfaces. This is a lot of material to present in a day, when you combine language and library, so the vast majority of examples to teach the language features and design will be pulled directly from the standard library. For example, the thread library will be introduced to teach move semantics (locks) and perfect forwarding (thread/function) - although additional time will taken to provide a solid grounding in the thread library too. Likewise, iterator categories, containers and algorithms provide great examples for concepts, and various approaches to designing concept-enabled libraries, but this also provides an introduction to the revised library. As far as possible the material will be supported by publicly available compilers, although there is no single compiler that covers everything (yet). Specifically all of the planned second and third sessions can be supported today via ConceptGCC, GCC4.3, or the VS2010 preview.
Keynotes
Geeks, Nerds and Other Prejudices (Susan Greenfield)
60 mins
The question of women's performance in the workplace, particularly in science and technology, has never been so important as it is today, nor more controversial. Scientists are often regarded as geeks and nerds and these prejudices are particularly worrying when applied to women scientists. Women leaders in science and technology need to dispel myths, unplug bottlenecks and side-step traps, which would have been unrecognisable to their mothers and grandmothers. Thankfully neuroscience is providing insights into some of these issues, with techniques ranging from genetics to brain scanning. Moreover, at the intermediate level of brain organisation, there exist highly dynamic, extensive networks of brain cells that are exquisitely sensitive to the environment. It is this highly malleable level of brain function that we can call 'the mind'.
We shall explore whether being female is 'all' in the genes, the impact of the environment, and indeed whether or not female scientists are 'normal'. We shall also discuss the bottlenecks that prevent a women leader in science and technology realising her full potential, and try to establish how to ensure that the largest number of women in the future are able to crash through the scientific/technical glass ceiling.
Considerations for Successful Management (Allan Kelly)
60 mins
"the quality of the people on a project, and their organization and management, are much more important factors in the success than are the tools they use or the technical approaches they take." Fred Brooks, Mythical Man-Month, 1995
The management of software development is often seen by developers as a dark art. While the tools and technology race a head management is too often stuck in the 1950s.
In this keynote Allan sets out key considerations for the better management of software development.
The Benefits of Abstraction in Patterns (Linda Rising)
60 mins
Pattern writers, like the rest of us--are limited by their own experience. We are biased toward the solutions we have used and tend to view them as the most useful way to solve the problems we face. These solutions are the ones we choose to document if we think about writing patterns and pattern languages. We typically don't examine other domains, looking for similar patterns with different implementation strategies, or try to deal with the challenge of higher or lower abstraction levels. Pattern writing is difficult and time-consuming, and, most of us, as in other areas in our lives, take the shortest possible path. This presentation is about a different kind of journey--unplanned and wobbly--one pattern author's struggle to find the right level of implementation detail and abstraction level.
The Birth of Software Craftsmanship(Robert Martin) {Slides}
60 mins
Over the last 50 years software has grown from a laboratory curiosity to a globe spanning profession. Most of us carry millions of lines of code around with us in our daily lives. That code has been produced by a cohort of people in search of a profession to call their own. But it is only in the last decade that the shape of such a profession has begun to be realized. We thought we might be scientists. We thought we might be engineers. It turns out, that we are craftsmen. In this talk Uncle Bob Martin talks about what it takes to be a software craftsman, and what is needed to complete the transition and claim our profession.
Welcome Crappy Code - The Death of Code Quality (Nicolai Josuttis) {Slides}
60 mins
Once upon a time we were able to develop software the good way.
We had time to design and implement a solution for a particular requirement affecting a particular system.
These times are gone.
Today we don't have enough time for quality, because the marketing guys rule the world.
And system development becomes only a footnote of the broad and boring maintenance of system landscapes.
This change requires new approaches and patterns for a software development process.
We already learned some things:
We use agility to deal with changing requirements and SOA provides solutions for heterogeneous environments instead of fighting for harmonization.
But an important next step is still missing, the way to deal with a lack of code quality.
In this talk, Nicolai Josuttis will demonstrate on real world examples, why and how the world is changing, the impact of this change for software development and the necessary next step we have to take.
A step some people will consider to be an unconditional surrender.
Sessions
'Refactoring without ropes' - changing programs in the real world. (Roger Orr) {Slides}
90 mins
Refactoring is currently a hot topic in the programming community and several development environments now come with refactoring tools built-in.
There are some interesting technical challenges with refactoring (for example, it is particularly hard in C++ because of the complexity added by macros and templates) but how does changing programs work 'in the large'?
In the same way that practising climbing on an indoor climbing wall is not the same as actually taking on a real mountain, we face challenges when taking refactoring from simple example programs to real-world applications.
These challenges include:
- Coping with large programs
- no one person knows all the codebase
- the tools used may only be able access some of the source code at any one time
- multiple programmers may be making concurrent modification to the codebase
- providing good migration paths for existing code
- Refactoring distributed systems
- loose coupling and mixed languages can affect refactoring
- not all components can be released simultaneously
- Reducing risk
- trying to prevent unexpected side effects
- providing safe rollback when the new version of the program fails
- Management buy-in
- refactoring is not supposed to make any change in functionality, so how do you get budget and timescales for it?
I'll look at these problems that seem to happen in practice when changing programs, and cover some techniques for ameliorating their impact.
Some general experience of modifying programs will be assumed, but specific specialized knowledge is not necessary for the session.
AJAX for Mobile Devices - Using Apache Projects to get the job done (Roland Tritsch) {Slides}
45 mins
Developing applications for mobile devices is challenging.
Mobile devices have unique requirements with respect to resource usage, management and connectivity. This talk will show how to implement AJAX applications for mobile devices (e.g. iPhone and Blackberry) using Apache Projects (e.g.
Apache ServiceMix and Apache CXF). We will first discuss/present the currently relevant software development approaches for the mobile device and their relative merits. We will then move on to discuss the specific characteristics of a Mobile-SOA platform and how to expose services to a mobile device. Last but not least, we will give a quick introduction to AJAX programming and show how open source projects can be used to implement mobile architectures/platforms. At the end of this talk to audience will know, if and how the AJAX approach is suitable for their requirements and how to architect solutions for this approach.
Adopting Model-View-Controller in Cocoa and Objective-C (Graham Lee)
45 mins
Learning the Objective-C language is not a big barrier to entering the world of Cocoa development, but the dynamic and introspective nature of its runtime suggests approaches to design which might not be familiar to programmers coming from Java or C++. In this presentation I will describe some of the Objective-C language features, and demonstrate how they are employed in Apple's Cocoa framework to produce highly cohesive application code following the SmallTalk Model-View-Controller pattern. The talk will not cover iPhone development explicitly but many of the ideas and patterns described will be transferable to Cocoa Touch development.
Agile makes Progress Transparent: But Who Wants to be Confrontated with the Reality? (Jutta Eckstein)
90 mins
Frequent feedback in agile development leads to a high transparency regarding the progress, the development, and the process by visualizing all (intermediate) results, all problems, and risks. This transparency enables continuous optimization of all our work. Therefore agile development requires continuous learning and adjustment. This sounds all very positive, because it means that we get better all the time. But what happens if you are working in a culture where nobody wants to gain knowledge particularly about what's not working, because the corporate motto is 'What you don't know won't hurt you.' In this talk I want to report on how different projects handled the (unfamiliar) transparency especially of displeasing things and how this handling sometimes destroyed all agile expectations.
Agility, Business Value and the 13 Axis of Software Quality (Schalk Cronje)
90 mins
Software development is not an island with an organisation. It should be fully integrated into the enterprise to be effective and as such quality concept of software extends far beyond the notion that "if it does what the specification says, it is good to go".
Agile approaches have many years now been the swan song of consultants, process authors etc. as the way forward to cope with fast-changing demands of business. Yet, in practical terms, many agile teams have been cutting meat instead of fat in order to be lean.
In this session I propose to show how some of the quality shortcuts often seen in Agile software development teams can be mitigated. By looking at quality from a more holistic point of view I'll show how good quality software links directly to business value.
The session will also offer practical advice on how get specific metrics in place to help improve the quality process.
Bigger, better, more: C++ 0x the standard library (Thomas Witt) {Slides}
90 mins
When we talk about C++0x, the new core language features tend to become the focus of attention. As a result it is easy to overlook that C++0x will also bring significant changes to the C++ standard library. This is apparent by looking at the relative sizes of the library sections in the C++03 standard and in the C++0x Working Draft. While the library section in C++03 included more than 350 pages, it is a little shy of 800 pages in the C++0x Working Draft. A lot, but not all of the expansion is due to the inclusion of parts of TR1. C++0x will also provide entirely new libraries like the atomic operations library and the system error facilities.
Apart from the change in scope there are also significant changes to the existing components. This includes minor extensions (copy_if, anybody ?) as well as changes to accommodate new language
Boiler Plating Database Resource Cleanup in Java (Paul Grenyer) {Slides}
45 mins
Java is a garbage collected language. If garbage collection is meant to help you clean up memory, why hasn't something been developed to help objects release resources? Java has finalizers, but as Joshua Bloch points out in Effective Java finalizers cannot be relied upon. Proper cleanup of resources is left to the developer whose only real friend is finally.
I have already covered database resource cleanup using the Finally for Each Release pattern in the January 2009 edition of CVu. To get the audience familiar with the problems and the scale of the unnecessary amounts of code that must be written repeatedly, I will first get them to help me write some JDBC code to execute an update statement and then expand it to execute and process the result set from a select statement.
Then I'll use the Execute Around Method pattern to show that most of that code only needs to be written once. Along the way I'll briefly discuss the pros and cons of checked exceptions versus runtime exceptions and briefly touch on inheritance versus composition in Java. I have assumed that the audience will have a reasonable understanding of Java, including features such as generics and anonymous classes.
Collaboration, Coordination & Culture Change - Being the Spider in the Centre of the Web (Astrid Byro) {Slides}
90 mins
How does one politely and diplomatically initiate a culture change in an organisation that has a long history of balkanisation? This talk will comprise an examination of the techniques that I have successfully (!!!) used in this situation as well as a roundtable to discuss the application of these techniques in various scenarios.
Concurrent Programming in the D Programming Language (Walter Bright)
45 mins
Many-core concurrent programming offers exciting and compelling advantages. The single core, single thread programming model is assumed by imperative programming languages. This model offers sequential consistency as its fundamental characteristic.
Because many-core systems use layered cache memory systems, sequential consistency is not guaranteed among threads.
Because imperative programming languages allow implicit sharing of data between threads, many misguided idioms and optimizations are possible that erroneously assume sequential consistency.
One example of this is the double checked locking optimization.
The pernicious nature of these sorts of bugs is they defy programmers' natural intuition about how programs behave, they are not statically detectable, and there is no way to reliably test a program to rule out the existence of such bugs.
A program may appear to work, but have problems appear years later, fail when ported to a different platform, and such problems may be extremely hard to reproduce and track down.
In essence, the correctness of the program relies entirely on the expertise and care of the programmer.
This is not an acceptable situation for developers of programs that require high reliability.
The D programming language is an imperative programming language with an innovative type system that prevents implicit sharing and also fosters a complete, integrated pure functional subset.
It is possible to statically verify that D programs do not have sequential consistency bugs. The double checked locking optimization bug is not possible. Type support for shared data and immutable data, as well as pure functions, means that mutating data interactions between threads can occur only under carefully controlled conditions.
This dramatically reduces the problem space for concurrency bugs from the whole of the source code to a small subset of it, making it a much more tractable problem.
Concurrency and Performance Reloaded (Kirk Pepperdine)
90 mins
This talk was inspired by the a comment made by both Intel and Microsoft in which they said that we, as developers, need to start delivering more concurrency in our applications. Thus the biggest challenge facing developers today is; how can we adjust to this new multi-core landscape. Our biggest obstacle is devising ways of getting work done is the pessimistic locking style forced upon us by the environment in which we much work. In this talk we will advances in the JVM and the JDK that we can use to help us to move to a more optimistic programming style. We well also explore some coding techniques that we can use today to help us meet the challenge of delivering more concurrency in our own applications.
Concurrent Programming with the Cell Processor (Dietmar Kuehl) {Slides}
90 mins
Processors won't become significantly faster: the clockrate can't be increased much further and the time it takes to execute individual operations also can't be tweaked much more. However, the processing speed can be increased by having more, although probably simpler, processors. Also, multiple pieces of data can be processed with each operation. The Cell processor as used e.g. in a Playstation 3 provides significant processing power by having multiple simple SIMD (single instruction, multiple data) enabled cores controlled by a more complex core. The individual processors don't immediately share memory although data can be transferred efficiently between the cores. This presentation provides and overview of the involved technologies, the associated programming model, and shows how to program for the Cell processor in C++ using a simple example.
Although the Cell processor is currently still relatively exotic it is expected that similar approaches will be used by future processors and thus similar programming techniques will become more common, too.
In particular, this presentation will
- give a brief overview of the overall architecture of the Cell processor
- describe the tools used to program for the Cell processor
- show how processes are distributed to the various cores
- show how data is transferred between cores
- give an introduction on how to take advantage of SIMD in C++
- provide an outline how the technical details can be hidden in C++
Controlling Project Risk by Design (Niels Malotaux) {Session Materials}
90 mins
A lot of risks that plague projects have a high probability to occur: e.g. the risk that we don't deliver the right things or deliver late, and the underlying causes of these problems. This calls for proactively anticipating potential problems and organizing our projects in such a way that the probability of the impact is minimized.
The Evolutionary Project Management (Evo) approach is just doing that, constantly being aware of what could go wrong and preventing it going wrong, by design. In stead of assuming a theoretical model of how humans "should" behave, Evo studies real human behaviour and strives to make optimum use of how humans actually behave. After all, opposing what's in our genes is a lost battle.
In this presentation we will first investigate prevailing risk management. Then we show how Evo practices are designed to systematically mitigate typical risks in projects. It turns out that most so-called risks are hardly risks, but rather excuses which easily can be avoided.
The techniques discussed are not merely theoretical ideas, but have been tested, honed and proved by the author in the practice of more than 100 projects in various environments and cultures.
Cranking Policies Up (Andrei Alexandrescu) {Slides}
90 mins
What if progress in languages and libraries would reduce Modern C++ Design to a little brochure? Would that mean policy-based design is obsolete? In fact, any simplification of complicated technology means that more progress can be made using the better technology as a starting point. Language and library implementation progress in the C++ and especially D programming languages does indeed reduce the need for drudgery in policy-based designs. That puts us in the enviable position of being able to capture more and larger design patterns with policies. This talk builds on recent progress to crank policies up toward comprehending larger and more elusive patterns.
Deception and Estimation: How We Fool Ourselves (Linda Rising) {Slides}
90 mins
Cognitive scientists tell us that we are hardwired for deception. It seems we are overly optimistic, and, in fact, we wouldn't have survived without this trait. With this built-in bias as a starting point, it's almost impossible for us to estimate accurately. That doesn't mean all is lost. We must simply accept that our estimates are best guesses and continually re-evaluate as we go, which is, of course, the agile approach to managing change. Linda Rising has been part of many plan-driven development projects where sincere, honest people with integrity wanted to make the best estimates possible and used many "scientific" approaches to make it happenall for naught. Re-estimation was regarded as an admission of failure to do the best up-front estimate and resulted in a lot of overhead and meetings to try to "get it right." Offering examples from ordinary lifeespecially from the way people eat and drinkLinda demonstrates how hard it is for us to see our poor estimating skills and helps us learn to avoid the self-deception that is hardwired in all of us.
Defining Domain-Specific Modelling Languages (Juha-Pekka Tolvanen) {Slides}
90 mins
Everybody would like the productivity benefits of modeling with full code generation, but the upgrade path from coding to modeling seems a closely guarded secret. This session will demystify Domain-Specific Modeling, open the lid on the OMGs MDA, and shine a light on Microsofts Software Factories. We will show which bits of Model-Driven Development (MDD) work, which might work, and which dont, and explain where they can be applied, and where not. Most importantly, we will show the steps to define your own modeling languages and generators to start using models effectively, road-tested in dozens of projects over a decade.
Design Patterns with modern C++ (Peter Sommerlad) {Slides}
45 mins
The original Design Patterns book by Gamma, Helm, Johnson, and the late Vlissides showed example code in C++ for most of the patterns. At the time of its writing in the early 1990s the only reliable way to implement the polymorphism required were virtual member functions in C++. Some people were reluctant to use them, because of the potential run-time overhead and also because of the tight coupling introduced by inheritance. Current standard C++ language and libraries provide more features to map the problems of some Desgin Patterns to more efficient C++ code.
This talk will show how to use static polymorphism provided by C++ templates or other C++ mechanisms than virtual methods, to implement some of the classic Gang-of-Four Design Patterns in C++. Especially those Design Patterns, where dynamic exchange of objects is not required, but initialized once, are possible. Examples shown include Template Method, Strategy, Decorator, Command, and Null Object. The "curious recurring template parameter" pattern also occurs.
The audience is welcome to share their experiences and variations.
Audience: Developers knowing the classic Design Patterns book with its 23 patterns and interested how they translate into the current decade's C++.
Designing 'Good' Components, Interfaces, and Contracts (John Lakos)
90 mins
In our component-based development methodology, virtually all of the software we design will ultimately be rendered as components. When we say component in C++ we are referring to a .h/.cpp pair (of files) satisfying certain well-established, objective physical properties (which we will review). Our experience tells us that software projects (especially large ones) implemented as collections of components (having acyclic physical interdependencies) tend to be relatively easy to understand, test and maintain, when compared to those employing less-structured implementation strategies; still, not all physically sound components are good ones. In addition to objectively verifiable physical design rules, there are also objective logical criteria pertaining to component interfaces and contracts that we must satisfy. All essential behavior must be documented, but there are important advantages, with respect to development, verification and testing, performance, and stability, for leaving the behavior for some combinations of inputs and initial conditions undefined. What is and is not defined behavior should therefore be readily discernible from the contract. Proper contracts involving each of the three kinds of inheritance – (1) Structural Inheritance resulting from non-virtual functions, (2) Interface Inheritance resulting from pure-virtual functions, and (3) Implementation Inheritance resulting from non-pure virtual functions – have different criteria that must be addressed. These logical properties of "good" components, along with the importance of Design by Contract (DbC), Defensive Programming (DP), and what we call Narrow Interfaces (and Contracts) are the focus of this talk.
Designing for testability (Sami Vaaraniemi)
45 mins
Why Unit Tests?
Creating good unit tests is a non-trivial task. We want to be sure that we get something in return for the effort of writing tests.
Unit testing brings along a number of tangible advantages over other testing strategies. A good unit test suite integrated in a build removes much of the ad-hoc nature that is the underlying reason for problems that continue to plague software projects. The net effect of the advantages is to make writing software more predictable and repeatable in short, more like a real engineering discipline.
How to unit test?
We take a look at desirable and undesirable properties of unit tests. Bad (unit) tests can be counterproductive and will end up wasting time rather than saving it.
Antipatterns Designing with no testability in mind can easily gridlock the code into the single context in which the code was initially meant to run. We take a look at how decisions made during the initial coding phase lead to untestable code.
Patterns for testability We take a look at frequently-occurring patterns and idioms that help in making code testable. Most of these involve identifying and breaking dependencies to parts of code that are problematic from the point of view of testability. Designing for testability means writing code so that it is decoupled from dependencies. This has the positive side-effect of making code more reusable.
Code samples Testability patterns demonstrated via a small sample application.
Designing multithreaded applications in C++0x (Anthony Williams) {Slides}
90 mins
This talk will cover the issues involved in designing multithreaded applications, along with examples of how to approach them from a C++0x perspective. This will therefore cover the use of the new C++0x thread library, and how features such as futures can affect the programming model.
Embedded Objects with C++ -- C++ Idioms, Patterns and Architectures for Constrained Systems (Detlef Vollmann)
90 mins
Architectures for embedded systems typically don't look like architectures for desktop or server applications. And architectures for 8-bit sytems look different than architectures for multi-process 32-bit systems. The same goes for design and language idioms:
embedded software is just different.
While embedded systems are vastly diverse, the still share some common problems for which quite a number of specific patterns emerged:
Architecture patterns that define the separation of concerns, between hardware and software, and between different software components.
Design patterns that solve problems typically arising in system level software.
And Idioms, that leverage language features to access hardware.
This talk will present a variety of patterns and anti-patterns for embedded systems. While most of these patterns are demonstrated using C++ and Linux, they are generally not specific to this combination, but apply to other operating systems and implementation languages as well.
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.
Embedding IronPython and the Dynamic Language Runtime in .NET Applications (Michael Foord){Link to material}
90 mins
IronPython and IronRuby are programming language engines built on top of the Dynamic Language Runtime (DLR). They have been designed to be easy to embed in .NET applications written in C# and VB.NET, opening up all sorts of interesting new possibilities. These include:
- Allowing user scripting by exposing an API from your application to scripts
- Prototyping parts of your application in Python or Ruby (often called rapid application development languages), or even making part of your application dynamic
- Allowing business rules or logic to be changed at runtime, or to be expressed in a Domain Specific Language stored as text and and executed with the DLR
During the talk we'll work through one of the embedding examples from "IronPython in Action". The example is a C# Windows Forms application that loads user plugins at runtime (with autodiscovery) and exposes an API to them. As we're executing and calling into arbitrary code at runtime from C#, we need to ensure we have appropriate error handling in place.
Exploring design space with interactive pattern stories (James Siddle, Kevlin Henney) {Slides}
90 mins
The workshop will have two aims. First, to introduce attendees to the concept of interactive pattern stories as a means of learning and teaching software design, and second to gather feedback on specific interactive stories to provide input to a book writing effort.
The first part of the workshop will consist of a presentation to introduce the concept of interactive pattern stories and provide a short demonstration. The second part will be interactive, where participants will separate into groups to 'play' stories provided in printouts. After reading the stories, the group will discuss what they learned.
The groups will be asked to discuss:
- what they learned from the stories
- alternative story paths they may have thought of
- ideas for other pattern-based interactive stories
- what they liked or disliked about the format
More information about Interactive pattern stories can be found in the paper "Choose Your Own Architecture - Interactive Pattern Storytelling" (http://www.jamessiddle.net/docs/cyoa.pdf) which was recently workshopped at EuroPLoP 2008.
Fearless Change: Patterns for Introducing New Ideas (Linda Rising)
360 mins
We attend conferences or read books and articles discover new ideas we want to bring into their organizationsbut we often struggle when trying to implement those changes. Unfortunately, those introducing change are not always welcomed with open arms. Linda Rising offers proven change management strategies to help you become a more successful agent of change in your organization. Learn how to plant effective seeds of change, and what forces in your organization drive or block change. In addition to using these approaches to change your organization, you can use them to become a more effective person. Come and discuss your organizational and personal change challenges. Linda shows how the lessons from her book, Fearless Change: Patterns for Introducing New Ideas, can help you succeed. Learn how to overcome adversity to change and to celebrate your improvement successes along with your organization's new found practices.
Fresh Paint (Alisdair Meredith)
90 mins
Summary:The new C++ standard includes many improvements in language and library that make the basic act of writing code simpler, clearer and more consistent. This session will show you how to write exactly the same programs you do today, only better! One day, all C++ code wil be written this way...
Description:
This session will walk through a number of the new C++0x features designed to make the language more teachable, more consistent, or just simpler to use. This will yield a worked example of taking an existing piece of code and transforming it into the 'new style' C++. Unlike the tutorial above, this will not really include any new 'features', but rather focus on improvements on existing features, or the cleaner replacements for them.
The goal is to give a vision of what 'regular' C++ might look like in 5 years time, if C++0x is a success. Features covered will include new initialization syntax, new function syntax, type aliases, auto, new constructors, unique_ptr, std::function and lambda, new for-loops and more!
Where possible this will be illustrated with recent compilers, but not all features are available today.
Functional Programming in F# (Oliver Sturm) {Session Materials}
90 mins
F# is a multi-paradigm language, but its syntax heritage comes from a functional world. Functional Programming is one of the main benefits that F# brings to the .NET platform. It encompasses many distinctive approaches and techniques, and this session provides an introduction to some of them, including the use of higher order functions, recursions and continuations, functional precomputation and memoization. The session requires a good understanding of F# foundations and syntax.
Getting a grip: Resource Management in practise (Ric Parkin)
90 mins
Dealing with resources is a vital part of writing software, and the developer's tool box has accumulated many techniques for encapsulating and managing them and their lifetimes.
In this talk we look in depth at some of these, from familiar out-of-the-box options such as Garbage Collection and IDispose in C# and C++'s standard auto_ptr, and a look at the upcoming unique_ptr and shared_ptr. What are their design goals, implementation details, and how can we use them best?
Following on from that we'll design and implement our own generic Handle, with particular reference to making C-style APIs easier and safer to use, and show how they work in the real world.
Growing Object-Oriented Software, Guided by Tests (Steve Freeman, Nat Pryce)
360 mins
Test-Driven Development (TDD) is a deceptively simple idea: write the tests for your code before writing the code itself. We say "deceptively simple" because this reversal fundamentally changes the role of testing in the development process. The tests are now about helping the team to understand the features that the users need and delivering those features reliably and predictably. When followed to its conclusions, TDD changes the way we develop software and, in our experience, hugely improves the quality of the systems we build.
This advanced tutorial is for developers who have started with Test-Driven Development and are looking for deeper understanding. We will show how TDD fits into the whole development lifecycle, with an extended example started from scratch.
We will cover topics such as:
- What's the point of Test-Driven Development
- Kick-starting the TDD lifecycle
- Growing features test-first
- Maintaining the TDD lifecycle
- Object-oriented design with Mock Objects
- Working with third-party code
- Learning to listen to the tests
- Testing asynchronous code
Holistic Security (Alan Lenton)
90 mins
The security of a system is only as strong as its weakest link. It's important, therefore, not only to consider obvious things like cryptography and access control, but also the other links in the security chain. The include, but are not limited to, social engineering attacks, application code security and whether the security methods are so onerous that the users actively subvert it in order to do their work.
The presentation will provide an overview of of the main links in the security chain, and look at how they fit together and interreact with one another. The presentation will examine existing problems, and how they have been solved (and broken) in the past, and what lessons can be drawn from them. The presentation will also look at a case study of some of the new (and old) security issues arising from the increasingly wide use of Web 2.0 applications such as social networking sites.
Introducing Parallel Pixie Dust: A Novel C++ Threading Library. (Jason McGuiness) {Slides}
90 mins
Over recent years there has been considerable development of multi-core processors, which increase architectural performance by providing thread-level parallelism. To maximise the performance of software on those architectures, programmers would have to write their code to exploit that thread-level parallelism, implying knowledge of that hardware. But from the programmer view-point writing parallel code correctly and efficiently, for an underlying hardware, has been non-trivial.
The usual library-based approach has been very problematic. In particular, locking has not been found to be composable, because it is an aspect of the code: it cross-cuts the usual approaches of functional decomposition or object-orientation. The portions of code that express parallelism have been intimately entangled with the business-logic code. This has resulted in reductions of code re-usability and increased complexity for testability.
The presenter took on a challenge: how much could be achieved with a C++ thread library? (Timely, when considering the current C++ standardisation effort relating to threading.) The goals tackled by the author were: To simplify making use of any parallelism by providing not only thread pools and futures, but efficient parallel algorithms. Also to guarantee that race conditions and deadlocks would not be present. That the program would execute an efficient parallel schedule. Moreover, to address the issues of debugging such parallelised programs.
Such a combination might be considered a difficult, possibly unattainable ideal. This presentation describes a library, Parallel Pixie Dust, PPD, written by the presenter, which he contends has largely achieved those aims!
Iterators are Out, Ranges are In (Andrei Alexandrescu) {Slides}
90 mins
In the early 1990s, the STL emerged as a compelling generic library of fundamental containers and algorithms using iterators as their common currency. Celebrated for transforming an n*m problem into an n+m problem, iterators soon became a staple idiom of C++ programmers. Some noticed that often iterators make most sense when trafficked in pairs, and soon Boost added a range type that makes that connection explicit. This talk argues that in fact ranges should be the primitive type and not iterators. Ranges embody a better abstraction, are easier to implement, easier to make safe, and work naturally in areas where iterator-based designs are tenuous. The setup and interesting consequences of range-based designs are discussed.
Javascript the language (Tony Barrett-Powell) {Slides}
90 mins
Javascript is widespread; it is available in every browser, a number of applications and is making its way onto the server-side. Javascript, like C++, supports multiple styles of programming; procedural, OO and functional styles are all supported.
This session explores the language that is Javascript. Starting with understanding where the language comes from and its prototype basis, looking at the syntax and how to make sense of it. The session will look in detail how Javascript supports procedural, OO and Functional styles with examples to illustrate the recommended syntax for these styles.
Along the way the session will highlight features of the language that should be avoided, typical gotchas and newer features which overcome some of the existing problems. The session will also look at the tool support for Javascript; those for checking and debugging. Finally the session will look at where Javascript is going; the enhancements to OO support and the changes to syntax.
Intended Audience: anyone who adds a little Javascript to a web-page, writes Javascript based thick clients or uses the language on the server-side and is interested in understanding Javascript a bit better.
Kanban, Flow & Cadence (Karl Scotland) {Slides}
90 mins
Some teams struggle to get buy-in to use Agile methods such as Scrum, or experience difficulty implementing the approaches successfully. This results in the teams being less effective than they could be, and can give a poor impression of the benefits of Agile development. Kanban, Flow and Cadence (KFC) are three important Lean concepts which can be combined to generate a more pipeline-based approach to software development, as opposed to the more common timebox-based approaches used by more traditional Agile methods. Using Kanban, Flow and Cadence can smooth transitions to Agile development, or further improve the productivity of existing Agile implementations. The presenter will describe his experiences implementing these ideas at Yahoo! and explain the concepts using examples, simulations and games. This tutorial will be relevant for anybody with some experience in Agile development, looking for new ideas which they might apply to their own environments. The presentation grew out of a number of OpenSpace talks, was given at AgileNorth in April (alongside David Anderson), more recently, was given as a half day session at Agile 2008, and has been accepted for XPDay London 08 and SPA2009.
Legacy code - learning to live with it (Pete Goodliffe) {Slides}
90 mins
Legacy code. You can't live with it. You can't live without it.
Well, you can't avoid it, at least. Spend long enough in the software factory, and you'll inevitably run into other people's old code. And of course, none of this old stuff is any good. It's nothing like the high quality software you craft. Pure tripe.
Let's be honest, sometimes you might even stumble across some of *your own* old code, and embarrassing as it is, you have to admit that you don't know how it works, let alone how to fix it.
This presentation will look at practical strategies for working with "old" crufty code. We'll see how to:
- start working with a completely unfamiliar codebase
- understand old spaghetti programming
- make correct modifications
- prevent bad code from causing more pain in the future
Lightning talks (various speakers) {Slides}
120 mins
Locating and Addressing Performance Issues (Diomidis Spinellis) {Slides}
90 mins
The ever increasing size of data sets, the adoption of sophisticated software stacks, the large storage access latencies, and the stagnation in the processor clock speeds are making performance an increasing worry for developers. In this tutorial we will see how we can locate the source of performance problems and ways to solve them. We will work top-down, looking first on why we might care about performance, where our software spends its time, and how we can identify those trouble spots. Depending on the type of workload were facing, we will then examine specific tools we can use to drill-down towards the source of the problem and solve it. Areas we will examine, include network performance, the overhead of operating system calls, disk input/output, specific program constructs, and algorithms. Fortuitously, some of the workload examination tools we can use are part of stock Unix and Windows distributions. Moreover, DTrace, a far more advanced tool, allows us to examine concurrently and non-intrusively many levels of an execution stack, including the operating system, the runtime environment, and our application. To look at our own code, we can also use function profilers, or even basic-block counting techniques. We will see representative examples of these tools for C, C++, and Java code. With access latencies of various storage technologies differing by many orders of magnitude it is also important to manage these as efficiently as possible. We will therefore discuss the role of memory consumption in our programs performance, how we can profile its use, and techniques to write more efficient code. Finally, we will look at parallelism, why it is difficult to exploit it, and some easy ways to cheat around the problem.
Measuring the Effect of TDD (Keith Braithwaite)
90 mins
Continuing work previously presented at a number of sessions at XpDay, Spa and Agile conferences (see http://peripateticaxiom.blogspot.com/2006/05/complexity-and-test-first-0.html and its siblings for more detail). The presentation section exhibits some statistics on the distribution of cyclomatic complexity per method in OO code. A singe characterisitc number capture the shape of these distributions. Evidence collected so far suggests that the use of Test-Driven Development (including a Refactoting step) has a recognisable effect on this number.
In the workshop section attendees will be equipped with some sfotware to study these distributions in thier own code and examine the impact of design choices on them. At present this software works only on Java source, but coud be extended to work with C++.
Memory Allocation and Garbage Collection in Java (Angelika Langer)
90 mins
In Java, allocation and deallocation of heap memory are handled by the virtual machine, i.e., by its memory manager and its garbage collector. This concept frees developers from the chores of explicit memory allocation and deallocation and eliminates the pitfalls that explicit memory management comes with, e.g. there are no memory leaks or dangling pointers in Java. Despite of this undeniable benefit, Java programs occasionally exhibit performance defects that are caused by excessive memory allocation or massive and timeconsuming garbage collection. In order to eliminate these adverse effects on the program's overall performance, a Java developer needs an understanding of the memory allocation and garbage collection strategies of the JVM.
The tutorial gives an overview of various garbage collection algorithms employed by the Java virtual machine of Sun's JDK 6 including tips and tricks for tuning the garbage collector, use of memory profilers and garbage collection profilers. We will also briefly touch on escape analysis, which is an optimization technique used by the JVM to completely eliminate heap memory allocation and deallocation for certain objects.
Modelling archetypes (Hubert Matthews) {Slides}
90 mins
Classes in domain models come in different flavours. Some represent relatively static entities; some represent transactions or events. These different archetypes form patterns in models. Knowledge of these patterns provides a systematic approach to modelling a wide range of systems. It also shows how such models provide insights into many aspects of systems such as caching, performance, data volumes, access control, reuse of data, components, as well as how they link to business processes, service-oriented architectures and enterprise service buses.
The approach presented is based on a wide range of sources ranging from Schlaer-Mellor through Coad's modelling in colour to Jackson System Development. The speaker has used it for teaching UML and object-oriented analysis and design for many years.
Objective-C in 90 minutes (Phil Nash)
90 mins
With the ever increasing popularity of Apple's Mac computers, and particularly with the launch the SDK for the iPhone and iPod touch devices, there has been a surge of interest from developers in the Objective-C language that is so central to those platforms. Objective-C is a relatively modest object-oriented extension to C which was eclipsed by C++ early on and dropped to near obscurity until Apple bought NeXT, along with their heavy investment in the language, and brought their Objective-C frameworks to the forefront of a new generation of platforms.
Now many are curious about the new-old-kid-on-the-block. How hard is it to learn? What are its strengths and weaknesses? Can you mix it with C and C++?
The good news is that it is very easy to learn, especially for C and C++ developers, although the alien-looking syntax puts many casual onlookers off at first. With a little guidance you can easily and quickly get past this and start writing like a native. Many have come to prefer it, especially liking the narrative readability of its unique method labelling syntax (at least, unique to those not familiar with Smalltalk).
This crash course presentation is from the perspective of a C family (C, C++, C#, Java) developer who learnt the language, then designed, wrote, and successfully launched, an iPhone game - written entirely within Objective C - and all within the space of a few weeks!
Paradigms of Programming: Lit. Crit. for code. (Steve Freeman, Michael Feathers) {Session materials}
90 mins
Object-oriented, Functional, Rule-Based, Dataflow, Structured, Constraint-based... There are so many ways to write programs, each of which is effective for a particular kind of problem. But the code most of us get to work with still feels like Cobol with braces, and we're working in "Enterprise" languages. As Robert Floyd said in his 1979 Turing Award talk, "If the advancement of the general art of programming requires the continual invention and elaboration of paradigms, advancement of the art of the individual programmer requires that he expand his /repertory/ of paradigms." This workshop will explore how we can become more sophisticated in our approach to programming. We'll look at different paradigms of programming, showing what they're useful for with examples in their "native" languages. Then we'll look at how we might use these techniques in our workaday languages (i.e. Java and C#). We think of this session as a version of the Literary Criticism we all hated at school. We want to take the time to deeply understand code, how it's made up, and where its features come from.
Patterns for Distributed agile Developement (Keith Braithwaite)
90 mins
In 2005 Tim Joyce and I published the first peer-reviewed account of successful Distributed Agile development. These two papers (see http://www.keithbraithwaite.demon.co.uk/professional/papers/ ) describe a number of organisational and team behavioural patterns that we had used successfully in our work and had found described as being used elsewhere.
Since then, disitrbuted teams have become more and more common. This session presents the 2005 patterns and describes the advances in distirbuted agile develpoment that have occurred since then. In the workshop part attendees will be invited to compare these pracrices with their own work and with a bit of luck identify some new candidate patterns.
Patterns for Versions, Releases, Compatibility (Klaus Marquardt)
90 mins
Who builds software has an interest to finally bring it to the users. Suddenly, another kind of trouble arises. How do I identify a version so that users can make some sense of it - as well as developers when offering updates or support? When and how do I release software? For software systems, how do I design compatibility - or should I exclude it in some situations?
This workshop collects practices from these domains and relates them to each other to create re-useable sets of patterns that apply to many projects.
Patterns of Simplicity (Peter Sommerlad, Kevlin Henney, Giovanni Asproni) {Slides} {Session Output}
90 mins
Continuing the theme of exploring simplicity in code and software development from previous years, this session looks to uncover some patterns that help to keep or make things simple. Part lecture and part workshop, this session starts by reviewing the notion of simplicity before highlighting the role that patterns can offer in mining and communicating practices that promote essential simplicity over accidental complexity.
What patterns of design, from the fine grained to the large scale, do we see in code that we consider to be simple? In what ways are these different to the patterns or combinations of patterns we find in code we consider complicated? What patterns can we find that help with the act of simplifying a software system?
Practical Erlang Programming (Simon Thompson) {Slides}
90 mins
Erlang, which came out of research labs at Ericsson, supports highly concurrent systems from telecoms switches to messaging applications and web-based systems, built by start-ups and corporations alike.
Erlang is a functional language, with message-passing concurrency and scalable multicore support. The OTP middleware library provides support for fault-tolerant distributed Erlang-based systems.
This session will introduce the basics of sequential and concurrent programming in Erlang, as well as exploring how to build an OTP application. Real-world examples will illustrate how Erlang is used in practice, and project undertaken recently in the Erlang community.
Processors Processors Everywhere, But How Do I Actually Use Them (Russel Winder) {Session Materials}
180 mins
The conceptual shift in hardware architecture labelled "the multicore revolution" has been made -- multicore, parallel systems are now widespread and increasingly the norm. There still remain many significant design and architectural challenges in moving from devices with four cores to those with thousands of cores, but the important thing is that this transition is now accepted as inevitable by most observers. In contrast, the software part of the revolution has hardly started either in terms of concept or design.
The era of ever increasing speeds of uniprocessors has ended. Processor manufacturers have changed their strategy to one of creating ever increasing numbers of cores per processor, all operating at speeds that stop the chips getting meltingly hot. They argue that these multicore processors actually execute more instructions per second than uniprocessors with much faster clock speeds, so applications performance is now a software problem. And they are not wrong. The problem is that software development still (in the main) revolves around a uniprocessor mindset. This is not going to be a viable strategy for future software evolution. Parallelism is finally here (after 30 years of being "the next technology"), but the software world is still fundamentally stuck in a uniprocessor mindset.
Since the beginning of software development, let's say c.1950, people have been worrying about how hardware and software can do more than one thing at once. Concurrency focused on how to manage a uniprocessor so as to give the appearance of parallelism. Java brought this to the fore by making threads a core (!) part of the language. Prior to Java, concurrency constructs were the preserve of specialist niche programming languages or library-based extensions. Java has really benefitted from this stance in that now that operating systems offer thread pools to access the real parallelism associated with multicore processors, Java is already a parallel language -- of a sort. But the average programmer has real problems with concurrency, let alone parallelism. Threads and synchronization generally blow programmers minds, and deadlock and livelock result. Java is trying to evolve to deal with this, cf. java.util.concurrent and JSR166y.
C++ is well behind, C++0x is just getting to the stage of specifying a thread model for C++. However, with the introduction of futures, it could catch up quite fast. But will there be a compiler and runtime system to allow test programs to be written by the time of the ACCU 2009 conference?
What about the other popular programming languages, Python, Ruby, C#, Visual Basic? Python and Ruby are renowned for failing to deal with parallelism. Well actually Python 2.6 has the multiprocessing package which deals with things very nicely. Instead of programming with threads, you program with processes and message passing. This sounds very much like the way occam and Erlang deal with parallelism. There is even a mathematical theory, Communicating Sequential Processes (CSP), that admits the possibility of proving that programs will or will not deadlock or livelock. Of course many programmers using dynamic languages say "processor count is like memory management something the runtime system should just deal with".
Computing began by handling parallelism using processes and message passing. It then moved to using shared memory multi-threading but it may well be returning to processes and message passing as the proper tool for the management of parallelism at the applications level. In the high performance computing (HPC) arena, MPI (message passing interface) has near total dominance as the tool of handling mutlicore and cluster-base parallelism (in Fortran, C and C++) -- though OpenMP has some market share. Erlang too takes a very CSP-oriented approach. Now Python is going the same route. Perhaps soon Java and C++ will. Will occam arise again? Probably not, but the process-oriented, rather than thread-oriented approach seems to be winning as the "right" model for applications development.
This session will investigate, with demonstrations, how these various mainstream languages deal with real parallelism. Taking a few example algorithms and coding up in the various languages with various techniques, we will investigate what programming idioms might be in this brave, new, parallel world.
Programming in a Multilingual World (Ewan Milne)
90 mins
The ACCU has long been interested in a variety of programming languages, and in recent years we have seen an increasing awareness across the industry of the benefits of applying a toolkit of languages appropriate to particular tasks within an organisation or project, rather than a one-size-fits-all approach. Common platforms have opened up access to a wider selection of languages for developers, while a number of new, or newly popularised, languages are appearing. How well will these assist us in tackling the development challenges we face?
In this session a panel will discuss the current programming language landscape, and the pros and cons of the multilingual world we now find orselves in.
Programming without getters (Mike Hill, Steve Freeman)
90 mins
In this Coding Dojo (http://codingdojo.org/) the participants will work with the session leaders to refactor an existing Java codebase (with existing unit tests and system tests). The existing code base is written using a commonly-seen style of Java development - POJOs (plain old Java objects) that have little or no behaviour - just simple getters and setters. We propose to refactor the codebase towards a "tell don't ask" programming style - our task will be to remove all the getters!
RDF, OWL, SPARQL and the Semantic Web (Seb Rose) {Slides}
90 mins
The Semantic Web (a.k.a. Web 3.0) was first popularly articulated by Tim Berners-Lee in an article in Scientific American in 2001. Since then there have been a lot of acronyms under the bridge but precious little visible progress to the end user. The use of RDF by the largely ignored RSS 1.0 specification was a highpoint in a process that has had precious few widespread successes (FOAF is one).
However, there has been a lot of progress in the areas of standardisation and tooling and we may see an accelerated uptake of Web 3.0 technologies over the next few years.
This tutorial will very briefly cover the motivation behind the Semantic Web before diving into some of the technologies that underpin its potential. We will examine the basics of RDF, RDFS and OWL before developing a minimal ontology. This will enable us to explore some of the similarities and differences between modelling in RDFS/OWL and Object Oriented modelling and introduce us to some of the simpler patterns used by ontologists. Finally, we will look at SPARQL, the standard query language, and look at the usage and adoption of SPARQL endpoints in some of todays commercial and open source software.
RESTful Services and Distributed OSGi - Friends or Foes (Roland Tritsch) {Slides}
45 mins
OSGi is on the rise. In the next couple of years OSGi has the potential to become the predominant deployment platform for Distributed Service Oriented Systems. This talk will first outline and introduce all relevant standards and trends around OSGi. We will then introduce OSGi in general. This will allow the audience to get a good basic understanding of what problem OSGi is solving and how it is solving this problem. The main part of the talk will then discuss what options you have today to expose and consume WebServices that are deployed in an OSGi container with a special focus in the deployment of RESTful services. The talk will conclude with a discussion of current challenges and possible future developments. After the talk the audience will have gained a good understanding of what OSGi is all about and how it can benefit them in their SOA deployments.
Reverse Engineering Patterns: I wouldn't start from here if I were you. (Mark Dalgarno)
90 mins
'Inheriting' code you don't really understand can be a painful experience. Whether it's a big ball of mud, spaghetti or just plain weird we all will typically have to work on such code some time in our careers.
This session describes some practices for systematically approaching the task of reverse engineering such code to help reduce the pain of working with it.
Along the way we'll pick the brains of audience members by way of group exercises looking at different aspects of the reverse engineering problem.
Revisiting The Visitor: The 'Just Do It' Pattern (Didier Verna) {Session Materials}
90 mins
A software design pattern is a three-part rule which expresses a relation between a certain context, a problem, and a solution. The well-known "GoF Book" describes 23 software design patterns. Its influence in the software engineering community has been dramatic. However, Peter Norvig notes that "16 of [these] 23 patterns are either invisible or simpler [...]" in Dylan or Lisp (Design Patterns in Dynamic Programming, Object World, 1996).
We claim that this is not a consequence of the notion of "pattern" itself, but rather of the way patterns are generally described; the GoF book being typical in this matter. Whereas patterns are supposed to be general and abstract, the GoF book is actually very much oriented towards mainstream object languages such as C++. As a result, most of its 23 "design patterns" are actually closer to "programming patterns", or "idioms", if you choose to adopt the terminology of the POSA Book.
In this talk, we would like to envision software design patterns from the point of view of dynamic languages and specifically from the angle of CLOS, the Common Lisp Object System. Taking the Visitor pattern as an illustration, we will show how a generally useful pattern can be blurred into the language, sometimes to the point of complete disappearance.
The lesson to be learned is that software design patterns should be used with care, and in particular, will never replace an in-depth knowledge of your preferred language (in our case, the mastering of first-class and generic functions, lexical closures and meta-object protocol). By using patterns blindly, your risk missing the obvious and most of the time simpler solution:
the "Just Do It" pattern.
Scala and the web: using Lift to write a simple CMS (Guy Bolton King) {Slides}
90 mins
Scala is one of the newer functional programming languages. It runs on the JVM, and can thus use the huge ecosystem of existing Java technologies to get things done. One of these is, of course, the Java Servlet specification, and the Lift framework plugs into this to provide a rapid web-application development platform.
In this tutorial-cum-case-study we'll take a whistle-stop tour of the Scala language itself, then dive into Lift and see whether or not it's easy to build a simple Content Management System using it. Lift is very much a work in progress, so this session may well contain some insights on what it's like to work on shifting sands!
Seven Tips to help get you started on multicore (Stephen Blair-chappell, James Reinders)
45 mins
By 2009 almost all servers,laptops and desktop PC's will have multicore processors, yet the software development community is understandably rather slow at adopting the parallel paradigm. In this presentation we give seven tips that will help the developer to embrace parallel programming in legacy and new applications. These tips are based on experience gained in real-world applications. The underlying technical limitations and challenges of programming for multicore are discussed along with implementation examples. The tips include 'best known methods' for introducing parallelism at the design, implementation and debugging stage of an application development. Whilst the majority of the presentation is clearly focused at using the latest available technology to implement parallelism, reference is made to upcoming / future trends based on R&D efforts.
Stop the Software Architecture Erosion (Bernhard Merkle) {Slides}
90 mins
On the one hand I will show how you can improve (or boost) your Software Architecture.
Unfortunately in lots of software projects architectural erosion happens over time.
In this session we will be looking how to avoid such architectural decay and degeneration and how continuous monitoring and making corrections can improve the situation.
In addition we will look at "refactoring in the large" and how refactorings can be simulated.
On the other hand, we will apply Software Architecture Analysis Tools (like e.g. SotoArc, Bauhaus, Structure101 etc) to existing projects and see how far an architectural erosion already has happened.
I will especially focus on open source projects and the boost c++ library in particular, as those projects have a large user base, (manually) paying attention to these projects.
We will see, how far an automated and tool supported approach can lead to better results and how they can discover areas of erosion and suggest improvements.
The future of Agile (Allan Kelly)
90 mins
Agile development is well established – even if it isn't omni-present. Even so it is changing, the issues people face with Agile are different to the issues they faced a year or two ago. New ideas and processes are emerging. And then there is Lean – will Lean oust Agile? And what is the difference between them?
In this session Allan will look at some of the emerging trends in Lean and Agile development and give some predictions for where it is all heading. As usual, audience participation is expected.
The Model Student Episode II: A Fresh Hell. (Richard Harris)
90 mins
Dazzled by streaming video, mashups and the prospect of making a killing in the Internet Bubble 2.0, the modern programmer has perhaps forgotten the true purpose of computing machinery, joining instead the boisterous hoi polloi in cries of Groovy this, XML that and Extreme Programming the other.
In this session, we shall put away these childish things and recollect the adult concerns of yesteryear, when mainframes less powerful than today's digital watches were properly employed solving the Important and Difficult mathematical problems of the day.
We could of course take a look at some of these historic Important and Difficult problems, such as simulating the detonation of fissile material, for example. However, their generally militaristic origins run contrary to my peaceful nature, they have already been solved and so will not teach us anything new and, finally, they are completely out of my rather limited mathematical reach.
Instead, we shall tackle some of the Important and Slightly Less Difficult mathematical problems of more recent times, such as determining the precise statistical properties of the Countdown Numbers Game.
The Pattern Buffet (Kevlin Henney, Allan Kelly)
90 mins
So many patterns, so little time to learn them. The Pattern Buffet collects together a number of pattern authors and practitioners to present bite-sized summaries of some patterns you may not have come across or may have only encountered by name -- or even to caution you against some patterns you may already know and use! Each presenter will take just a few minutes to explain their pattern or patterns of choice -- what you should know about it and why -- and answer any questions from the audience (briefly). For those interested in patterns at any level this session promises to be both lightning and enlightening!
Security in distributed systems and SOA (Nicolai Josuttis)
90 mins
As more and more systems are connected to system landscapes, we more and more face the challenge of security.
According to the concepts of interoperability "all doors are open".
But this is not always what we want.
There might be services, only some applications should call, there might be results only some consumers are allowed to see, and it might even happen that for security reasons it should not be possible to see that there is a services when a consumer is not allowed to call it.
In addition new technologies such as XML create new risks and features such as single sign on (SSO) are requested.
This talk will give a summary of my current knowledge about these topics. Based on real world experiences I will talk about XML bombs, security stacks, tokens, federations, and how these concepts impact the design of distributed solutions.
Up and running with C++0x (Alisdair Meredith)
360 mins
Summary:
This tutorial will break into three packed sessions. The first will take a look at the new standard memory model, support for concurrent execution and atomic operations. The second will take a look at designing new interfaces in code, highlighting rvalue references, variadic templates and lambda expressions. Examples will focus on how these features drive the new thread library, rounding out the concurrency support. The final session will take a deeper look at templates, with a major focus on concepts, introducing the new containers, iterators and algorithms library to provide examples. By the end of the day the attendee will be familiar with the major new language features and a large part of the library.
Prequisites: A good knowledge of existing C++ language and library, a passing knowledge of TR1 would help.
Compilers will be listed nearer the time (session 2 would use a mix of GCC 4.3 and VS2010 CTP, session 3 requires concept GCC, thread libraray via Boost or Just Software. Session 1 is mostly theory - but we expect a broader range of support before conference time) Description:
The goal of this tutorial is to teach the major new features of the new C++ standard. These are seen to be (i) concurrency support (ii) concepts (iii) features for better [code] interfaces. This is a lot of material to present in a day, when you combine language and library, so the vast majority of examples to teach the language features and design will be pulled directly from the standard library. For example, the thread library will be introduced to teach move semantics (locks) and perfect forwarding (thread/function) - although additional time will taken to provide a solid grounding in the thread library too. Likewise, iterator categories, containers and algorithms provide great examples for concepts, and various approaches to designing concept-enabled libraries, but this also provides an introduction to the revised library. As far as possible the material will be supported by publicly available compilers, although there is no single compiler that covers everything (yet). Specifically all of the planned second and third sessions can be supported today via ConceptGCC, GCC4.3, or the VS2010 preview.
What Motivates Software Developers? (Helen Sharp, Mark Dalgarno)
90 mins
What do you enjoy about developing software? What would make you leave one project and join another project? What kind of people do you like to work with? When does software development become a drag? In this workshop, we will use an interactive format to answer these questions and explore the effect of organisational, technical and social context on developer motivation.
The session is a mixture of presentation, group work and discussion and will be structured as follows:
- Introduction (10 mins)
- Discussion of general motivation questions (such as "What aspects of your job do you get most satisfaction from?")
- * small group discussion (20 mins)
- * plenary discussion and comparison (10 mins)
- Identify key factors in motivation
- * small group discussion (20 mins)
- * plenary discussion and comparison (10 mins)
- Presentation of findings from ours and others' research into motivation in software engineering (15 mins)
- Discussion wrap-up and (5 mins)
When is a specification sufficiently complete and accurate? (Derek Jones) {Session Materials}
90 mins
The European Commission antitrust action against Microsoft resulted in a judgment requiring Microsoft to make available "... complete and accurate ..." specifications of various server communication protocols. Your speaker was an adviser to the Monitoring Trustee appointed by the Commission to assist it with monitoring Microsoft's compliance.
This talk discusses what it might mean for a specification to be "...complete and accurate ...". and the issues that need to be considered when evaluating whether a set of specifications, containing over five thousand of pages, can be said to be "...complete and accurate ...".
Existing industry practices, economic issues and the practical interests of software implementors will also be covered.
Why Portable Code? (Steve Love) {Slides}
90 mins
The idea of writing code to be portable seems well understood - write once, run on many platforms - but this is often used as an excuse *not* to do it, from the "I only need to run on [Windows|Mac|Linux|Other]" developers. However, there's much more to portability than actual cross-platform development. This is partly a talk about the issues, and partly a discussion of some design, code and language choice techniques for approaching portability as an issue for software developers.
Advertisement
