Session details

Sponsored by:
Red Gate
Cititec
Blackwell
Methods and Tools
Erlang Solutions
Intel
QBS Software
Oxford Asset Management
Wolfram
RiverBlade
SkillsMatter
Syntagm
Just Thread
Organized by:
Conference Chair:
Giovanni Asproni
Conference Committee:
Astrid Byro
Francis Glassborow
Paul Grenyer
Alan Griffiths
Jon Jagger
Roger Orr
James Slaughter
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 archer-yates.co.uk
Conference 2011




The videos of the keynotes and some sessions can be found here

Preconference

A Day of Deliberate Practice (Jon Jagger, Kevlin Henney)

360 mins

How do you develop expertise? Peter Norvig writes: "The key is deliberative practice: not just doing it again and again, but challenging yourself with a task that is just beyond your current ability, trying it, analyzing your performance while and after doing it, and correcting any mistakes. Then repeat. And repeat again."

For a developer, deliberate practice means trying new things, trying old things with a view to making them fresh and trying to move from accidental practice to intentional discipline. Deliberate practice improves technical agility through increased self awareness.

During the day we will practice reflecting on what we do, working together and developing software, for which we will be using CyberDojo, an innovative, collaborative, browser based environment. We are going to have fun - don't forget to bring a laptop!

Keywords: Expertise, Skill, Deliberate Practice, Agile Development, Craftsmanship, Hands-on, Dojo

Target audience: Any programmer (past, present or future) who would like to reflect on, improve and practice their practice of programming

Cover All Your Testing Bases with the Agile Testing Quadrants (Lisa Crispin)

360 mins

Software quality has many dimensions, so we must be ready with different testing approaches. We test to find defects, ensure system reliability, check that the system is easy to use, verify that it's secure, and much more. How do you know the different types of tests you need? How do you know when you're "done" testing? Lisa Crispin shows you how to use the four categories of the Agile Testing Quadrants method to make sure your team has covered all the bases—programmer tests (test-driven development); customer tests that help the team meet the users' requirements; business-facing tests that critique the product's behavior and find the important bugs; and technology-facing tests that examine non-functional qualities such as performance, load, scalability, reliability, and security. With Agile Testing Quadrants, you and your team will be ready to cover all the bases—no matter what testing challenges the project throws at you.

The Java Memory Model (Angelika Langer, Klaus Kreft)

360 mins

The workshop discusses the Java Memory Model, the issues of visibilty and reordering, the use of volatile and atomic variable, the implementation of immutable types based on the memory model''s initialization safety garantee, and provides an introduction to the techniques of lock-free programming.

Description: The increasing availability of multicore processors requires that essentially all Java applications must be multi-threaded in order to take advantage of those applications'' cpu power. The transition from a single-core architecture to a multi- core or multi-cpu platform occasionally reveals bugs in the program: applications that worked properly and reliably in a single-core context suddenly and inexplicably exhibit errors in a multi-core context. Often this is due to the substantially more aggressive caching techniques used on the processor level in combination with misconceptions regarding the Java Memory Model on the programmer''s side. In order to avoid such misconeptions, the workshop discusses the Java Memory Model comprehensively and in depth. Java develeopers do not only need a proper understanding of the Java Memory Model. In addition, the elimination or at least reduction of sychronization is becoming increasingly important in a multi-core and multi-processor world. Using a multi-cpu platform users expect that an application should scale, that is, its performance should increase with the number of available cpus. This highly desirable effect does not occur automatically, but has to be built into the application. Sequential, i.e., non-parallel, parts of the program must be drastically reduced in order to utilize the multiple cpus effectively. There are several technique for reduction of sequential processing, among them the elimination of lock-based sychronization, but also the use of atomic operations and programming techniques such as lock-free programming. The workshop discusses the Java Memory Model, the issues of visibilty and reordering, the use of volatile and atomic variable, the implementation of immutable types based on the memory model''s initialization safety garantee, and provides an introduction to the techniques of lock-free programming. Since this is a workshop, participants will have opportunity to practice and apply the newly gained knowledge in hands- on labs. We will review code, spot bugs and fix them. In addition, we will use atomic variables to eleminate lock- based synchronisation. For the practice part, participants are asked to bring their notebooks.

Topics: Java memory model Visibility, atomicity, reordering Garantees for volatile Double-checked locking Initialisation safety of final fields Safe object sharing Atomic variables Lock-free programming

Audience: Java developers who develop multi-thread software and want to prepare their programs for use on multi-cpu platforms. Java developers with an interest in performance optimizations. Java developers with an interest in concurrent programming in general who want to brush up their knowledge.

Level: average to advanced

System Prerequisite: Notebook/PC with an installation of Java 6 SE. An installation of the test tool ConTest is recommended; the tool is available for download at www.alphaworks.ibm.com/tech/contest/download.



Keynotes

Advanced Simplicity (Giles Colborne)

60 mins

Every revolution in computing changes challenges us to create software for larger audiences. The personal compute, the WIMP interface, the web have all brought computing to a wider audience. The explosion of mobile computing - smartphones, tablets and so on - has massively expanded the audience for what we do.

Giles Colborne, Author of Simple and Usable: web mobile and interaction design talks about the challenges of designing for a mainstream audience and why consumers are far more demanding than experts. He'll use stories and examples from everyday life to look at the complex subject of 'simplicity' and unravel some of its paradoxes. He'll help you counter some common objections to keeping it simple. And he'll offer some strategies and tips for creating interfaces that you can apply right away.

On Our Ability to Do Much (Michael Feathers)

60 mins

TBA

Optimizing for Happiness (Tom Preston-Werner)

60 mins

The way traditional businesses approach the management and organization of creative, intellectual workers is wrong. By throwing away everything that blocks productivity (meetings, deadlines, managers, titles, strict vacation policies, etc) and treating your employees as the responsible adults that they are, huge amounts of potential can be unlocked and employee happiness and retention can be at unprecedented highs. At GitHub we've embraced a philosophy that gets things done and strips away policy and procedure in favor of smart decision making and personal responsibility. Come see how we make it work and how you can reap the same benefits in your own company.

Good Enough is the enemy of the Good (Nat Pryce, Steve Freeman)

60 mins

We spend too much of our working lives coping with inadequate systems on inappropriate kit. We are reassured that this is acceptable because we must "deliver value" and not be "perfectionist". This is just wrong. We've seen teams that have achieved orders of magnitude more effectiveness than their neighbours, not by cutting corners or superhuman effort but by "getting it right". Far too few of our industry colleagues have ever experienced working on an effective team, they literally don't know what they're missing.

In this talk, we will describe some of our formative experiences that led us to this (unproven) conclusion, and why we think that it's true. Then we will channel some of our rage about the state of the industry into suggestions for what we might do about it.

The Last Programming Language (Robert Martin) {Video}

60 mins

The territory of computer languages has been explored. We've seen routines, and subroutines, functions and procedures, objects and interfaces, logic programming, stack programming, data flow programming, graphic programming, and even programs made out of game-of-life.

We've seen languages that read like english, and languages that read like math. We've seen language made out of dots, and language made out of colors. We've seen languages with rich complex syntaxes, and languages with virtually no syntax.

In short, we've seen it all. In short, we've run the gamut. In short, though there will be new languages, they won't really be new.

And that means it's time to choose. It's time for the companies and special interests to get out of the way. It's time for the religions and fads to fade away. It's time for the vast sea of languages to evaporate.

Just as mathematicians finally chose arabic numerals, and Liebniz' derivatives; it's time for the community of programmers to pare down their choice of languages to a few, perhaps even to one.

So, what will the last computer language look like? What features will it have? What kind of syntax? What kind of structure?



Sessions

A practical introduction to common open source licenses (Alison Lloyd) {Slides}

90 mins

Most people have used some free or open source software at some point, and as the available selection of software grows, more and more companies are looking to use it too. However, the actual licenses under which OSS is provided vary widely, and may have very different implications, particularly for commercial users. This talk explores some of the more common OSS licenses in use, with an emphasis on what requirements they place on users, and how users can comply with those requirements. It is not intended to be an authoritive guide, but more a starting reference (IANAL, etc).

Agile C++ through Advanced IDE Features (Peter Sommerlad) {Slides}

90 mins

Many C/C++ developers I've met stick with their favorite program text editor when programming. In contrast, no Java developer would program without decent IDE support for navigation, code completion, library discovery, unit testing, and automated refactoring. In addition to the last two, an agile developer also expects feedback on code smells, coverage information on automated tests and more. There seems to be a great gap between C++ developers using vi(m) or emacs and Java developers using Eclipse or one of its competitors. Even in Visual Studio (unmanaged) C++ is a second class citizen compared to the .NET CLR languages.

No one seems to address the lack of decent and modern IDE support for C++. Therefore, students and assistants at IFS Institute for Software at HSR Rapperswil have created a variety of extensions for the Eclipse C++ Development Tools (CDT). Such as our CDT refactorings as well as the CUTE unit testing framework and plug-in. We also contributed to the improvements of CDT itself, which might have a bad reputation from the buggy and functionally limited early releases. However, as of today, we believe Eclipse CDT can be used even for larger projects successfully.

This talk shows how useful CDT can be for C++ development as well as it introduces currently available extensions developed by IFS and potential future inclusions, that have currently the status of student projects or prototypes.

You will see how quick navigation and auto-completion works, "hidden" features like macro expansion view help and how to refactor and unit test your code, also with code coverage. Some further extensions, like toggling (member-)function declaration/definition, introducing template parameters, e.g., for compile-time dependency injection, are not yet available publicly, but will be soon.

There is usually no need to fiddle with makefiles with CDT when starting out new projects, unless you are going cross-platform. Then Scons might be an option, which one of our students nicely integrated into CDT as well.

Depending on ongoing development further CDT extensions might be shown, fostering agile C++ development with CDT. Also traps, bugs and pitfalls will be covered, because as with all software, those still exist. I hope at least some of the text editor aficionados can be lurked to at least try if CDT can improve their C++ productivity, which in my opinion often should be measured by the lines you get rid of.

Agile Manifesto: 10 Years On, What can we do better? – A rewrite (Tom Gilb) {Slides}

45 mins

The intent of Agile has always been to focus on delivering value to our stakeholders But, I think we need to be a lot more specific about what this means, because some people think it means delivering bug free code to a user or customer, even if the stakehoder gets no real value!.

Revised Agile Principles

  1. Critical Stakeholders determine the values
  2. Values can and must be quantified
  3. Values are supported by Value Architecture
  4. Value levels are determined by timing, architecture effect, and resources
  5. Value levels can differ for different scopes (where, who)
  6. Value can be delivered early
  7. Value can be locked in incrementally
  8. New Values can be discovered (external news, experience)
  9. Values can be evaluated as a function of architecture (Impact Estimation)
  10. Value delivery will attract resources

Agile Software Development for Distributed Teams (Jutta Eckstein)

90 mins

On the one hand there are meanwhile not many projects left that are made at home without outsourcing, off- or nearshoring. On the other hand more and more projects discover the success factor of agile development which requests - among other things - an emphasis on face-to-face communication.

In this talk, Jutta will report from her experiences in bringing these two trends together and which practices help and which hinder the success of a project

The focus will be on how to apply agile processes in a distributed setting and how to establish and preserve a common development culture. Participants will learn how to adapt both simple agile practices like a Daily Scrum (also known as: daily stand-up meeting) and more complex practices like a retrospective to a distributed environment.

Attendees will understand that also distributed (and large) teams can benefit from a value system and from principles that are beneficial for small teams. In fact the two trends - distribution in terms of globalization and agility - can even complement each other.

Agile Team Excellence - supporting Agile in a 10,000 person organisation (Paul Field)

90 mins

With aspirations to become a world-class IT organisation, Deutsche Bank took the decision to invest in the agile teams that it found forming on the ground. Faced with an IT organization of 10,000 people and no information about what teams were agile and even what agile meant at DB, how did the Agile Team Excellence team approach the problem of creating world-class agile in a large, complex, geographically distributed company? Find out what they did, what worked, what didn't and see just how much hair they have left...

Becoming a Better Programmer (Pete Goodliffe) {Slides}

90 mins

You're a programmer. You spend your life programming. (You dull person, you!)

Don't you want to do it as well as you possibly can?

This entertaining talk will provide a number of practical, simple methods to become a better programmer. There will be plenty of hand-waving and jumping, a little philosophy, and much wisdom from our excellent programmer forebears.

Be the best programmer you can!

CPU Caches and Why You Care (Scott Meyers)

90 mins

No matter what programming language or technology you use, if your software fails to make effective use of the underlying CPU caches, your system's performance will suffer. This session provides a wide-ranging overview of your CPU caches, how they operate, and how that affects high-level decisions on things like data structures and traversal strategies. Both single- and multi-threaded execution are considered. Specific topics include different cache types (data, instruction, TLB); private and shared caches; cache lines and speculative prefetching; false sharing; and cache-friendly program organization, data structures, and traversal strategies. If you care about performance, the information in this talk is essential. The fact that it's really interesting is simply a bonus :-)

Choosing patterns for your parallel program (Anthony Williams) {Slides}

90 mins

There are many ways of structuring parallel programs, and a good many buzzwords surrounding them. In this talk I will look at several of the standard patterns that you can use to take advantage of concurrency in your application alongside the circumstances under which each might be appropriate. I will also talk about the various patterns for communicating between threads, how those relate to the structural patterns, and the trade-offs involved with the choices.

Code Entropy and Physics of Software (Jon Jagger, Olve Maudal) {Slides}

90 mins

While working on the Code Archeology talk that we presented last year, we realized that the "Physics of Software", and in particular Code Entropy, is a topic worth presenting by itself.

By observing how a codebase changes over time you start to notice there are strong and weak forces that shapes the code. We have studied a large and successful codebase written in C and C++ to find good observations and tried to identify the governing forces.

In the first part of the workshop we will hand out a questionnaire containing pairs of similar code snippets. These snippets, from a real C/C++ codebase, will be labelled as A and B. We will ask the audience (via group discussions) to predict which snippet came first; did A evolve into B or did B evolve into A?

In the second part of the workshop we will talk about information theory, annealing, multidimensional search spaces, maxwell's demon, and consider how these topics relate to software development. We will also present observations and speculative theories from a large codebase that we have studied.

For the session we need a room in cabaret setup, to support group interactions. Here is the proposed schedule:

  • Introduction (~5 min)
  • Survey and discussions within groups (hand-outs, ~20 min)
  • Slides (information theory, annealing, maxwells demon, etc, ~45 minutes)
  • Discussions between groups (results from survey, ~20 min)

ComputErl - Erlang-based Framework for Many Task Computing (Michal Ptaszek)

90 mins

This talk shows how the Erlang programming language can be used for creating a framework for distributing and coordinating the execution of many task computing problems. The goals of the proposed solution are (1) to disperse the computation into many tasks, (2) to support multiple well-known computation models (such as master-worker, map-reduce, and pipeline), (3) to exploit the advantages of Erlang for developing an efficient and scalable framework and (4) to build a system that can scale from small to large number of tasks with minimum effort. We present the ComputErl framework, and the promising results in preliminary experiments with benchmarks as well as real scientific applications deployed over hundreds of nodes.

Continuous Integration - Does it scale? (Dirk Haun) {Slides}

90 mins

Everyone agrees that Continuous Integration (CI) is a good idea. A more interesting question is to see how well CI setups scale.

In this talk, we will be looking into some edge cases, such as:

  • Many commits or committers. Can you still easily find out which commit broke the build?
  • Many machines or platforms. Can you still easily tell the current state of your system when all those machines are building a slightly different revision of your software?
  • Many branches. What happens when you introduce a Distributed Version Control System? How do you do CI on individual branches?

We will be exploring these and similar issues and will discuss solutions and alternative options. Additional input from the audience is very much welcome to get a better overview of the state of CI in nontrivial real-life setups.

CyberDojo (Jon Jagger, Olve Maudal)

90 mins

A CyberDojo is deliberately designed to stimulate deep experiential learning of both aspects of software development:

  • the technical side - coding and test-driven development
  • the social side - communication and collaboration

In a CyberDojo you practice developing software whilst playing "musical chairs"!

  • the players work in small groups
  • each group works at a single computer
  • each group writes their code and tests totally inside a CyberDojo web page
  • each group submits their code and tests to the CyberDojo server as often as they wish
  • the CyberDojo server saves their submission, runs their tests, and returns the tests-outcome to their browser (green if all tests pass)

To encourage collaboration every few minutes a bell rings indicating...

  • all keyboard drivers must rotate to a non-driver role
  • either at the same computer or a different one

A CyberDojo is fun and stimulating.

Participants are asked to please bring their laptop.

45 mins

This session will look at how to use C++ in resource constrained embedded devices for marine seismic acquisition systems. Taking a peek behind the C++ curtain, this talk will cover building your own gcc cross compile toolchain, hardware and runtime initialization, C++ on a diet, and building testable embedded systems.

Dealing with Defects - an Agile Approach (Lisa Crispin) {Slides}

90 mins

Lean development tells us queues are waste, but don't we need defect tracking systems? After all, most teams have a big backlog of bugs waiting around to be fixed - even though it's unlikely that very many will be addressed. Everyone's too busy dealing with the brand new bugs. Fortunately, teams have found ways to tackle the defect dilemma. Lisa Crispin will explain agile approaches to defect management, from "fix and forget" to lightweight defect tracking systems. She'll present examples of how agile teams handle defects, what works well, what doesn't work so well, and what you can learn from bugs. Most importantly, she'll discuss ways to shift your team's mindset from bug fixing to bug prevention.

Defensive Programming Done Right (John Lakos)

90 mins

In our component-based development methodology, each developer is responsible for ensuring that the software he or she creates is easy to understand and use, and not especially easy to misuse. One common form of misuse is to invoke a library function or method under circumstances where not all of its preconditions are satisfied, leading to undefined behavior. Contracts having undefined behavior are not necessarily undesirable, and (for many engineering reasons) are often optimal. Most would agree that a well-implemented library should do something other than silently continue when a pre-condition violation is detected, although these same folks might not agree on what specific action should be taken. Unfortunately, validating preconditions implies writing additional code that will execute at runtime. More code runs slower, and some would fairly argue that they should not be forced to pay for redundant runtime checks in the library software they use. Whether and to what extent library functions should validate their preconditions, and what should happen if a precondition violation is detected are questions that are best answered on an application by application basis - i.e., by the owner of main. "Defensive Programming Done Right" makes it all possible.

In this talk, we begin by reviewing the basic concepts of Design-By-Contract (DbC), and what we mean by the term "Defensive Programming" (DP). We then explore our overall approach to institutionalizing defensive programming in robust reusable library software such that each application can conveniently specify both the runtime budget (e.g., none, some, lots) for defensive checking, and also the specific action to be taken (e.g., abort, throw, spin) should a precondition violation occur. Along the way, we touch on how modern compilers and linkers work, binary compatibility, and the consequences of possibly violating the one-definition rule in mixed-mode builds. We conclude the talk by describing and then demonstrating our "negative testing" strategy (and supporting test apparatus) for readily verifying, in our component-level test drivers, that our defensive checks detect and report out-of-contract client use as intended. Actual source for the supporting utility components will be presented throughout the talk and made available afterwards.

Diet Templates (Jonathan Wakely) {Slides}

90 mins

"Template Bloat" was once commonly used as an argument against using C++ in new projects, often with little justification. Despite most claims being unfounded, templates can indeed result in "bloated" code, with the most obvious implementation techniques for generic code leading to not-so-obvious duplication, unnecessary coupling and real effects on runtime performance. In this talk we will explore how this happens and how to deal with it using code hoisting, separation of interface and implementation, and the odd extra level of indirection. The aim is to write templates that are both more generic and more efficient, without giving up the convenience or type safety of templates. The talk will involve code examples ranging from small demonstrations of problems and solutions to larger cases in widely used libraries, and obviously, lots of templates.

Distributed Computing 2.0 (Filip van Laenen)

90 mins

Web 2.0 technologies can be used to distribute distributed computing architectures even more than traditionally has been done. In particular, what would otherwise be a central database behind a central server can be outsourced to Web 2.0 services like Twitter, or constructed using RSS feeds. This can of course only be done for problems where the decision-taking process can be distributed as well, and in particular when a complete overview over all results submitted so far is not necessary. On the other hand, this is also an advantage and an opportunity, as it allows to a much larger degree the creation of specialized clients helping to solve the problem faster.

As an example, if Twitter is used, clients can publish their results as tweets, and can consume the partial solutions from their peers by following them and reading their timeline. New peers can be discovered in various ways, e.g. by searching for tags or checking out friends of friends. One can imagine that the vast majority of clients would be producing as many results as possible as fast as they can. Other clients could wade through the results to look for a final result to the problem at hand, or run statistics or publish reports.

This new architecture has some challenges attached to it too, especially in relation to the security. Clearly, injecting a false result, accidentally or intentionally, becomes trivial, and clients will therefore need to decide on policies in order to deal with them. They will also have to consider whether they will want to continue to trust the clients that injected the false results, and other results produced by these clients.

Distributed Version Control Systems - under the bonnet (Jim Hague) {Slides}

90 mins

For some time Distributed Version Control Systems have been the latest shiny toy in the version control system world. With no absolute dependence on a central server, they can offer both convenience, allowing checkins when no links to external systems are available, and the possibility of using workflows that are at best clumsy on Centralised Version Control Systems.

Like any tool, DVCSs work best in the hands of craftsmen who understand their strengths and their limitations. Central to that understanding is an appreciation of how the tool does its job.

This session gives a brief introduction to two popular DVCS, Mercurial and Git, and then dives under the bonnet (under the hood, if you prefer) of each of them to examine how they work. We'll look at the file layouts and data structures employed, how changes are passed from one repository to another, and highlight the assumptions and engineering tradeoffs made.

Establishing and Scaling Offshore Testing for Agile Teams (Chris Duro)

90 mins

As they undertake more agile projects, IT enterprises are seeking to scale the use of offshore testing on agile teams. What lessons are being learned about this and what techniques are working, particularly with respect to testing? We will share experiences from actual projects deploying outsourced testing staff to support automated and manual testing for agile projects. Attendees will learn of key challenges facing agile offshore testing as well as specific solutions such as:

  • Fitting agile testing into an organization's overall adoption of agile
  • Establishing agile testing within traditional QA departments
  • Scaling up offshore testing communication and productivity
  • Preparing new testers to join agile teams
  • Adapting traditional GUI test automation for agile teams
  • Using metrics to evaluate agile testing effectiveness

Facilitating LEAN Problem Solving Sessions(Astrid Byro)

45 mins

We all solve problems but are we solving the root cause or just the symptoms? This talk will examine common techniques for root cause analysis - Defining the problem with 4W1H and finding the root cause with 5 Why's, Affinity Diagrams, Fishbone Diagram, and Tree Structures.

Facilitation Patterns and Antipatterns (Steven List)

90 mins

Facilitation skills are essential for anyone. In fact, everyone facilitates whether they know it or not! Do you work on a team, manage an organization, or otherwise work with others? The opportunity to facilitate will come up.

Steven 'Doc' List will lead you to explore the common patterns & antipatterns that come up in facilitation, for the facilitator and the participants. We'll have some fun by taking on roles, and exploring the behaviors that work and that don't work. The session will include some time on specific activities and techniques that can be used for effective facilitation.

Process/Mechanics The first third of the session will be a short presentation about the fundamentals of facilitation and an introduction to Doc's Patterns and Antipatterns work.

The next third of the session will be spent in discussion/interaction. Attendees will be grouped randomly, and each group will hold a discussion. Before the discussion, each group member will be given a pattern/antipattern to represent, and they will be expected to behave as their pattern/antipattern in terms of motto, beliefs, behaviors, and characteristics. The rest of each small group will then be encouraged to identify each other group member's pattern/antipattern by name at the end of the discussion.

Two discussion rounds will be held, with each group member being assigned two patterns/antipatterns in the second round.

This will be followed by large group discussion, specific stories of experience, and/or with discussion of how to deal with, encourage, discourage, or otherwise address that pattern/antipattern, whether exhibited by self (facilitator) or participant.

The remaining time will be spent reviewing specific activities that can be used and how they apply. Sources will include Agile Retrospectives by Diana Larsen and Esther Derby and Collaboration Explained by Jean Tabaka.

Example Patterns and Antipatterns Note that more detail is available on my blog at http://www.stevenlist.com/blog/category/musings/facilitation-musings/

  • Antipatterns: Superhero (rescuing, caring), Professor Moriarty/Evil Genius (conniving, manipulating, conspiring), Gladiator (combative)
  • Patterns: Neutral, Guide, Curious George (asking, not telling)

Learning outcomes

  • Recognize patterns and antipatterns in meetings and facilitation
  • Apply some specific techniques to address antipatterns
  • Learn activities and techniques to use to facilitate meetings

Farewell to Disks: Efficient Processing of Obstinate Data (Diomidis Spinellis)

90 mins

Questions whose answer requires sophisticated processing of huge data sets come up increasingly often in our networked and interlinked, and (increasingly) DNA-sequenced world. Attacking such problems with traditional techniques, such as loading data into memory for processing or querying a relational database, is cumbersome and inefficient. Data sizes are growing inexorably, while disk-based data structures and applications relying on them, optimized to handle sequential retrievals and relational joins, often prove inadequate for running complex algorithms. Therefore, sophisticated processing of huge complex data sets requires us to rethink the relationship between disk-based storage and main-memory processing.

Some features of modern systems, namely 64-bit architectures, memory mapped sparse files, virtual memory, and copy on write support, allow us to process our data with readable and efficient RAM-based algorithms, using slow disks and filesystems only for their large capacity and to secure the data's persistence. I demonstrate this approach through a series of C++ programs that run on Wikipedia's data looking for matching words and links between unrelated entries. Through these programs I will show how we can use STL containers, iterators, and algorithms to access disk-based data without performing any system calls. Although RAM-based processing opens up again many problems that database systems already solve, I will argue that such processing is the right move, because it provides us with a unified programming and performance model for all our data operations irrespective of where the data resides.

Generic Programming with C++ 0x (Dietmar Kuhl)

90 mins

C++Ox provides several new featues which help with the use and implementation of generic components. Although the flagship feature (concepts) was withdrawn other still remain and this presentation describes some of the new features applicable in the generic area. In particular it coverss lambda functions, the new function declaration syntax, automatically deduced types, variadic templates, and initializer lists.

Writing code applicable in more than a specific situation requires the use of some form of genericity, especially in statically typed languages. When the actual types are known only at run-time, the use of virtual functions is the way to go. However, in many situations the actually involved types are known statically and using them directly makes generic components typically both easier to use and faster. The support for static polymorphism in C++2003 is lacking some features making it often quite hard to implement generic components as well as making their use unnecessary hard. In the upcoming C++0x several of the problems are addressed. This presentation will demonstrate the use of these features as they apply both to users as well as implementers of generic components. It will only discuss features already implemented in publically available compilers (in particular in gcc), i.e. this won't be a presentation about C++ language features hopefully appearing some time in the features but it will show how the language can be used right away. Although the main focus will be core language features, the presentation will use library components new in C++Ox where applicable.

GoLightly: Building VM-based Language Runtimes In Go (Eleanor McHugh) {Slides}

90 mins

The GoLightly library (http://github.com/feyeleanor/GoLightly/) is a toolkit for building flexible virtual machines. Instead of limiting you to a particular execution model it defines basic primitives which are useful in implementing stack-, register- and vector-based execution engines along with simple communications models for multicore designs.

GoLightly started as a research tool to help design a high-performance virtual machine for Ruby written in Go but its scope has since expanded to be a general-purpose library with the aim of allowing any high-level language runtime to easily exploit multicore concurrency and the vector-processing features of modern consumer processors.

In this session we'll draw on the GoLightly and related codebases to explore how Go supports concurrency as well as examining its approach to object-orientation and type safety - including the dirty tricks occasionally required to override it.

Here we'll also encounter the Go testing and benchmarking framework and use code examples to illustrate the many trade-offs involved in VM design including some or all of: dispatch models; bytecode and threaded interpretation; control flow and activation records; interrupts; memory allocation; stack- and register- architectures; vector-processing (SIMD) extensions; JIT and AOT compilation; system calls, blocking and processor-inspired weirdness.

By the end of the session attendees should be comfortable reading Go source code, have a basic feel for developing with the language and the necessary background to write their own VMs in whatever language they happen to prefer.

Growing a language... and drive a Lego/NXT robot (Bernhard Merkle)

90 mins

How can you extend your embedded Program in C or C++ to drive a (Lego/NXT) robot with an RTOS and at the same time program with domain specific language constructs (like "turn right, accelerate")? In this session we will show how to "Grow a language" and add domain specific constructs according to your needs. I will present the power of modular languages and illustrate and show the idea with an Open Source Projectional Language Workbench MPS in a realworld embedded software development scenario. Modular languages and Projectional workbenches enable us to grow a language really easy.

We often have the discussion whether a GPL (General Programming Languages) like C, C++, Java, Python, Clojure, Scala (insert your favourite language here...) is better than a DSL (Domain Specific Language). Currently the number of newly-created Programming Languages is significant. This is not only due to the fact that multi core hardware requires languages to efficiently exploit the new power (e.g. parallel and functional programming). However GPL (General Purpose Languages) do often not fit the specific need of the end-user, e.g. for web- or embedded- software development, so we need something more Domain Specific (aka. DSLs). We often debate about internal and external DSLs, however a new approach, modular languages is far more powerful and scalable. Combined with tool support like Projectional Language Workbenches (which deviates from the usual text- and scanner/parser-based approach), it is really easy to combine modular languages based on the users needs and build convenient IDE support at the same time.

In this session I will show how to "extend" the C Programming Language with domain specific language extensions for controlling a Lego/NXT robot. Despite the usual drawbacks of internal DSLs we will build "first class" language extensions with full IDE comfort and debugging support. The samples will run on a Lego/NXT robot, running a OSEK/RTOS with C as programming language.

How hard can it be? How never to learn from failure. (Ulf Wiger) {Slides}

90 mins

Do we ever learn from failure? Already in the Mythical Man-month, Fred Brooks talked about how programmers constantly underestimate difficulty, and, if they didn't, they wouldn't even dare to get started writing code. Programmers get to grips with hard problems by trying to solve them. Boldly exclaiming "how hard can it be?", we dive in, and often find out exactly how hard it can be. We then try to teach others, but find that they are dead-set on learning the hard way too. In this talk, we will explore with practical examples how this dynamic leads to repeated disasters when scaled to large projects.

Introduction to Scala (Peter Pilgrim) {Slides}

90 mins

  • Covering the Scala as an alternative JVM language to the Java.
  • Statically compilation versus dynamic
  • Functional inspiration of the language
  • Scala syntax, scripts, REPL,
  • Vals verses Vars
  • Classes and companion objects
  • Case Classes
  • Pattern matching
  • Traits otherwise known as Mixins
  • Collection classes and immutabiltiy
  • XML Literal Syntax

Just Keep Sending The Messages (Russel Winder) {Slides}

90 mins

Shared-memory multi-threading has for many years been presented as the idiom of choice for harnessing parallelism . C++0x gives even C++ a standard threads model, allowing it to catch up with Java which has had threads as standard for 16+ years (since Java's inception in fact). However, for most solutions to problems, shared-memory multi-threading is generally the main stumbling block to creating successful parallel systems. In the C, C++ and Fortran communities, OpenMP has arisen to try and abstract thread management, to make shared-memory multi-threading tractible. Software transactional memory is even making a play as the "silver bullet" for successful shared-memory multi-threading.

There are alternatives. Since the 1970s, there has been the Actor Model. Since the 1980s, there has been Communicating Sequential Processes (CSP). To add to these there is also dataflow software architecture. These models remove the need to consider all the synchronization and locking issues that plague shared-memory multi-threading. There is no claim of having found a "silver bullet" for parallelism, but it is probably the closest thing to one you will find.

Surprisingly the C, C++ and Fortran communities have been passing messages for many years: MPI, the de facto standard system for managing parallelism in these communities, is all about passing messages around. OK, so the messages look like individual primitive values, but from this protocols can be constructed.

This session will focus on designing systems as collections of small, lightweight processes passing messages, and the various different synchronization structures which differentiate Actor Model, CSP and dataflow. The session will look at examples using Erlang, Python (especially Python-CSP and PyCSP), Groovy (and the GPars library), Java, Scala (and the Akka library), Go, D, and C++ (especially the C++CSP2 library). Clojure may even make an appearance.

The outcome will, I hope, be that people start thinking differently about how to realize their algorithms in the increasingly parallel world of the post-Multicore Revolution world of computing.

Fun as well as edification will be had, it is mandatory.

Key practices to cope with complexity (Klaus Marquardt, Kevlin Henney) {Peter Sommerlad Slides}

90 mins

Complexity is a key risk to project success. While some projects suffocate from complexity while attempting to fight it, others almost ignore it with amazing grace. So what makes complexity appear a nuisance rather than a deadly risk? What are the key things that successful projects do right? This joint tutorial gives you 6 different insights, and practices you can learn from for your projects at home.

History: none. Format stems from the pattern buffet from ACCU 2009.

Presenters: to be announced, 6 in total, chosen from those that are present at ACCU.

Learning from the past: what might the next Java or .NET look like? (Jon Skeet)

90 mins

It's clear that C# and .NET used a great many of the ideas present in Java, as well as improving on it in various ways. However, some aspects of both platform leave something to be desired. While both languages (and the platforms they build on) are still evolving, it's worth considering what their successors might look like. Is there enough "wrong" with either platform to need anything else along the same lines? Is the future of "enterprise development" actually likely to consist of something radically different? Are static, object-oriented, mostly-imperative languages headed for oblivion?

In this talk, we'll have a look at some aspects of C# and .NET which have definitely been improvements over Java, and some aspects where more could perhaps have been learned. We'll think about some alternative approaches, and consider which areas of software development still just feel like they're harder than they really should be.

Lightning keynotes (Ewan Milne) {Slides}

60 mins

After their extremely successful introduction in 2010, we decided to have them again! The lightning keynotes is a 60 minute sequence of fifteen minute talks given by four speakers on a variety of topics. There are no restrictions on the subject matter of the talks, the only limit is the maximum time length.

We will select the keynote speakers at the conference itself.

Lightning talks (Ewan Milne) {Thursday Slides, Friday Slides}

60 mins

Each session of lightning talks is a sequence of five minute talks given by different speakers on a variety of topics. There are no restrictions on the subject matter of the talks, the only limit is the maximum time length. The talks are brief, interesting, fun, and there's always another one coming along in a few minutes.

We will be putting the actual programme of talks together at the conference itself. If you are attending but not already speaking, but you still have something to say, this is the ideal opportunity to take part. Maybe you have some experience to share, an idea to pitch, or even want to ask the audience a question. Whatever it is, if it fits into five minutes, it could be one of our talks. Details on how to sign up will be announced at the event.

A Common Lisp Tutorial: from the very basics to the power of macros (Didier Verna)

180 mins

In this tutorial, you will be introduced to the wonderful world of Lisp, the only language still used at large after more than 50 years of existence. After a brief history of the language, we will walk through the REPL, the basic data types and structures, some practical facilities for iteration, scoping, I/O etc.

Lisp is probably the most multi-paradigm language out there, because its philosophy is to give you more freedom instead of trying to impose a particular style of programming on you. Lisp can be imperative, procedural, functional, object-oriented, declarative, meta-level, dynamically or statically typed, or all of that at the same time. You choose. I will try to give you a feel of that.

Knowing that Lisp was designed around meta-circularity and structural reflexivity from the start (in other words, code is data; see my first talk on Thursday), it should not be surprising that it still is the most expressive language out there. Depending on time, I will also try to give an overview of CLOS, the Common Lisp Object System, one of the most expressive object layer out there, and the too often misunderstood macro system, again probably the most advanced meta-programming facility available today.

This is an hands-on tutorial. Attendees should come with their laptops and install one of the environments below

  • If you're an Emacs user my suggestion is to download and install:
    • SBCL: an open source Common Lisp implementation http://www.sbcl.org/
    • Slime: an interactive REPL-based environment for (X)Emacs http://common-lisp.net/project/slime/
  • Another alternative is to download LispWorks Personal Edition http://www.lispworks.com/ It is a commercial implementation but the Personal Edition is free. It comes with the language and an integrated IDE. Also probably the best choice for Windows.

Mastering Git Basics (Tom Preston-Werner)

90 mins

Git is the distributed version control system that's taking the world by storm. The Linux kernel, Ruby on Rails, and Erlang/OTP have all chosen it as their VCS of choice. This talk will focus on mastering the handful of commands that comprise 90% of the functionality you will use on a day-to-day basis. I'll kick things off with the best method to install Git on your favorite platform. Next up is creating local repositories, staging/adding files (all about the index), making commits, and viewing history. From there you'll learn to share your repositories with others via GitHub, fetch and merge changes that others make, and resolve conflicts.

Meta-circularity... and vice-versa (Didier Verna) {Slides}

90 mins

As complexity increases, one often feels limited by the use of a single language, and incorporates new technology in order to express the original problem more abstractly, more precisely, and design solutions more efficiently. Using better-suited languages also has the advantage of letting you think about your problem in new and different ways, perhaps ways that you had not thought of before. It is thus no surprise to see the profusion of new languages that we face today, notably scripting and domain-specific ones.

But then, why the need for all this new and different technology? Wouldn't it be better if your primary language could evolve the way you want it to? And why is it not generally possible? Perhaps, because your primary language is not really extensible...

Meta-linguistic abstraction, that is, the art of language design plays a capital role in computer science because we have the ability to actually implement the languages we design, for instance by creating interperters for them. A fundamental idea in this context is that an interpreter is just another program (by extension, one could argue that any program is an interpreter for a particular language).

In this session, we will revive a historical moment in computer science: the birth of meta-circularity. When, in 1960, John McCarthy invented Lisp, he discovered that given the core 7 operators of the language, it was possible to write Lisp in itself, by way of an interpreter. The practical implication of meta-circularity is that a meta-circular language gives you direct control over the semantics of the language itself, and as a consequence, means to modify or extend it. No wonder, then, why lispers never felt the need for external DSLs, scripting languages, XML or whatever. The reason is that Lisp, being extensible, can do all that by itself. Lisp is, by essence, the "programmable programming language".

Move Semantics, Perfect Forwarding, and Rvalue References in C++ 0x (Scott Meyers)

90 mins

From a performance perspective, the most important new feature in C++0x is move semantics, which makes it possible for compilers to replace costly object-copying operations with less expensive "state movement" operations. This session explains what move semantics is, how it affects program performance, and how programmers can control it. It also examines another new C++0x feature, perfect forwarding, because effective use of move semantics takes advantage of it. Finally, it takes a close look a third new C++0x feature, rvalue references, because that's the foundation on which both move semantics and perfect forwarding are built.

All three features explored in this talk are available in current compilers from major vendors (e.g., Gnu and Microsoft), so C++ developers will be able to put the information in this presentation to immediate use.

Multicore is dead; Long live Multicore! (Stephen Blair-Chappell) {Slides}

45 mins

Ten reasons why programming for multicore should be avoided. In this tongue-in-cheek session we take a head-in-the-sand approach to multicore programming. We present a number of anecdotal reasons why you should never program for multicore. Includes a rapid examination of several case studies. Warning: Content may be subject to exaggeration and hyperbola - after attending this session you may never write a parallel program again.

Overcoming Resistance to New Ideas / Breaking through the brick wall (Rachel Davies) {Slides}

90 mins

When you come to a conference like ACCU, you pick up new ideas that you'd like to try when you get back to work. However, you may feel like you hit a brick wall when it comes persuading your colleagues to try the idea out. Resistance is very common in organisations large and small. As an agile coach, I've learned that forcing adoption of new practice results in minimal compliance. Teams who don't want to be try the new approach often fall back to old ways of doing things. In this talk, I will share some tips for getting to the heart of resistance and how to dissolve barriers to adopting new working practices.

[Based on my Agile Coaching Skills training course and keynote at XPDays Germany]

Overview of Cloud Computing (Sven Rosvall) {Slides}

90 mins

Cloud Computing is a buzzword with many meanings and lots of promises such as infinite storage and dynamically expandable compute capacity at low cost. It also promises to take care of system maintenance. This talk demonstrates what is in it for you and how can you make the most of cloud computing? There are many players in this market, each with their own offerings and definition of what cloud computing is. This talk will describe the biggest players and typical cloud customers with some case studies. We will look at common building blocks in cloud computing offerings and how to use these for building scalable applications. We will also look at how to migrate your existing applications into the cloud. Developing scalable cloud applications differs slightly from traditional designs and we will outline nuances and pitfalls that must be addressed when developing in the cloud for the first time. To finish off we will demonstrate how to build a simple scalable application using these building blocks.

Pattern writing workshop (Klaus Marquardt, Allan Kelly)

90 mins

Have an insight? See something important? Want to share it? You are the only one who can share what you know. Patterns can help.

To realise the true power of patterns you have to write them. And writing patterns is the best way to deepen your insight, and address your reader.

In this workshop you will write patterns in miniature. We supply the problem, you supply the solution - and the words. Along the way you will understand how and why patterns work, see their variety, and learn practices that improve your writing skills. Whether you want to write your own patterns, better understand other patterns or improve your writing and critical thinking skills this workshop is for you.

Programming with the C++ 0x Standard Library - New Features, new Tools, new Patterns, new Pitfalls (Nico Josuttis)

90 mins

C++0x, the next C++, is close to being finalized, and it will have an enormous impact on C++ application programmers.

New libraries but also new language features will provide more features, give more power, and, to some extent, change the way you program in C++.

In this talk Nico Josuttis, the author of "The C++ Standard Library" will present all you should know about the new Standard from the point of view of an application programmer using the C++ standard library, including some hidden features and pitfalls.

Property-Based Testing, Race Conditions, and QuickCheck (John Hughes) {Slides}

90 mins

Property-based testing is an approach to test automation popular in the functional programming community, in which automated test cases are replaced by general properties that ought to hold in many cases, rather than just one. QuickCheck supports property-based testing by generating test cases from the properties, executing them, and adjudging the outcome. When a test fails, then QuickCheck "shrinks" it to a minimal failing example, which usually makes diagnosing the underlying fault very easy. In this way, QuickCheck reduces the cost of testing while at the same time improving its quality.

I will introduce property-based testing and demonstrate QuickCheck for Erlang, showing how to use it to test both Erlang and C programs. The latter uses Erlang to support model-based testing against finite state machine models, which are nicely represented in Erlang, exploiting its purely functional features.

In particular, property based testing can be used to test for race conditions---which are very difficult to test for with traditional unit tests, because the non-determinism inherent in concurrent tests mean that "expected results" do not exist. I will show how properties come into their own in this situation, and explain how QuickCheck was recently used to find a race condition that has been lurking in the Erlang database for years, causing errors every month or two in production systems.

Quantum Computing for Programmers (Paul Black) {Slides}

90 mins

Quantum computers could be vastly more powerful than current machines as atomic bombs are than gun powder. However quantum computers will not just be faster von Neumann machines. Only special algorithms and applications can get exponential speed ups. To begin I will teach basic complexity theory (so it will be useful) and quantum mechanics (so mere mortals can understand it). Next we'll delve into simple quantum circuits, like quantum communication that cannot be tapped and teleportation, and how to simulate them. Finally we talk vaguely about what quantum software would be. Vaguely? The biggest quantum computers built so far handles only 5 bits.

As a bonus, I'll give a free quantum simulator to everyone attending the session (download it here).

SELECT * FROM databases WHERE query_language <> 'SQL' (Gavin Heavyside) {Slides}

90 mins

Some have embraced the 'NoSQL' banner, some hate the term, but the world of non-relational databases has blossomed over the last few years. This has been driven by many factors, including large data volumes, fast performance on specific types of queries or updates, absence of fixed database schemas and more than a little bit of fashion. But how do you choose between Column-oriented (e.g. HBase, Cassandra), Document-oriented (e.g. CouchDB, MongoDB), Key-Value (e.g. Redis, Tokyo Cabinet) or Graph (e.g. Neo4J) for your next project? Or should you stick with your tried-and-trusted SQL database?

This session will introduce the different families of non-relational databases and their defining characteristics. We will see how each type of database can be applied and how to interact with them from your favourite language. We will learn how to choose between the wide range of non-relational databases, and when not to choose one at all.

Simple Software - Regain Control through Decremental Development (Peter Sommerlad) {Slides}

45 mins

Developing Software using the latest complex technology is cool. Software evolution by adding features and fixing bugs can be a burden. Both lead to brittle, buggy, overly complex and poorly performing software solutions. The value of Simplicity of a software solution is often neglected by many software people today. Making software simpler increases its value, because of lower maintenance burden and easier extendability. This talk explains what "simple" software means and how to approach it with "Decremental Development" even for existing (unnecessarily) complicated software.

Software has a problem: It is much easier to create complex solutions than to create simple elegant solutions. Thus most software is much more complicated and larger than it needs to be. This unnecessary complexity leads to lower quality and hinders further evolution. Space is no longer a problem in the computer, but the human brain capacity hasn't grown like computer memory capacity. Brains create software; therefore we need to understand software.

Time has come for a change: programmers must consciously reduce complexity and size of solutions to keep up with the growing problems to be solved. There is need for a dramatic reduction in program complexity: "Decremental Development" aims for reducing a system's size TO 10 % (a tenth) while improving quality and maintaining required functionality.

Less code means more software!

To progress in the direction of this goal requires change in several areas. One area is the underlying culture of our industry. A project approach to software development almost automatically leads to short-term solutions just barely working until the project is delivered, because a project manager is not payed for establishing long term success, but to deliver a product with as little resources spent as possible and on time. So-called software maintenance is often viewed as a low-profile job, close to being a janitor cleaning up the worst dirt. Another area is the qualification of developers. It is extremely hard for an outsider (=manager) to evaluate existing differences in talent and skill or at least to judge a really bad programmer from a better one. Sometimes the skill-level is just too low or too outdated. And I don't speak of mastering latest technology, but of understanding what one is doing.

Dirty code starts in the very small, like a dirty city starts with the first dog dropping on the sidewalk. So you can start today cleaning our code by just caring for cleanness, like the Swiss dog owners do with Robidog.

It is also OK to throw away useless or bad code. You can always recycle it from your version control system, if really needed. The fastest code is the one not there. Inexistent code also never has errors. Have courage to delete and change.

The current economic crisis might help us with a culture change, increasing the valuation of sustainable software and thus Simplicity in software design and code. Also software maintenance should not be viewed as it is. Valuable software is handed to a thousand code monkeys for maintenance with the hope it stays intact, but who would you hand a valuable painting for restoration?

We do not yet know all means or tools one can imagine to make software simpler and smaller with Decremental Development, but nevertheless you can start today by caring more about software quality.

Solid C++ (Olve Maudal) {Slides}

90 mins

Sometimes you see code that is perfectly OK according to the definition of the language, but which is flawed because it breaks too many established idioms and conventions. On the other hand, a solid piece of code is something that looks like it is written by an experienced person who cares about professionalism in programming.

This will be an interactive discussion about good vs bad C++ code. We will discuss simple C++ idioms and coding conventions, but we will also touch upon best practices when working with C++ in large codebases with lots of developers with mixed skills.

Software Naturalism - Form and Function in Untamed Code Bases (Michael Feathers)

90 mins

In the software development industry, we spend a lot of time talking about good design and not nearly enough about design as it is practiced normally. Every code base bears the mark of thousands of micro and macro code design decisions. In the end these decisions give code bases form and the form that they culminate in is rarely what we call "good" or effective design. In this session, Michael Feathers will review empirical research concerning long-lived code bases, describe the common forms that code often falls into over a period of time, and lead a discussion about how we might alter our notions of goodness in design in response to the bare facts about how our actions give code shape.

Stopping the rot - putting legacy C++ under test (Seb Rose) {Slides}

90 mins

Over the past year and a half we have been using the Googletest and Googlemock frameworks to put a 20 year old C/C++ application under test. We had major issues of unwanted and tangled dependencies (Big Ball of Mud; Spaghetti Code), which needed to be tamed to even allow a modicum of testing to take place. I will describe some of the specific difficulties we encountered and explore (where applicable) how we overcame them. With reference to refactoring patterns I will present the strategies that we employed, both new and old.

I expect that many of the problems we faced will not come as surprises to seasoned C++ practitioners and that our solutions may give hope to those of you who face the same challenges.

The session assumes no prior knowledge of the Google frameworks (or of unit testing in general), but will not cover these in detail.

Some objects are more equal than others - a look at the many meanings of equality, value and identity (Roger Orr, Steve Love) {Slides} {Richard Harris Apppendix Slides}

90 mins

Equality is a fundamental concept in programming but is surprisingly hard to get right. Its importance is shown by the way that in most languages it is a symbol (not even a keyword) - although the variation between "=" and "==" continues to catch people out!

In languages that allow you to define your own types it is important to get equality right -- but what does "right" mean in practice?

We will look at the slippery concepts of equality, value and identity and discuss what pitfalls there are in using them. This is important in places as varied as database persistence and reliable unit tests - and also becomes a 'key' issue when you are working with associative collections.

Equality can be hard enough to get right for a single class; but additional issues arise with hash codes for objects and when you start using class hierarchies. We will work through an example of trying to get this right based on experience with real-world problems.

Strategies for 24/7/365 SaaS (Jeff Kotula) {Slides}

90 mins

Virtual Radiologic Corporation (http://www.virtualrad.com) is a provider of 24/7/365 teleradiology services and software-as-a-service framework for thousands of clients throughout the United States, associated with numerous radiologists in the US and overseas. Designing and supporting a mission-critical, web-based software service in this environment presents challenges that must be addressed by a broad spectrum of tools, from technology to processes, to people.

This case study will examine the system design choices and approaches taken by vRad to deliver 99.9% (and better) availability in its RIS (radiology information system) and PACS (picture archiving and communication system). We will discuss hardware and configuration, software structure, operational support and processes and the key choices within each that enable our round-the-clock software as a service.

The Man Page of the Warrior of Light (Semen Trygubenko)

45 mins

Structured as an adaptation of Paulo Coelho's teachings for the striving for excellence member of programming community, this talk will cover values- and principles-based foundations for building good patterns and other technical and social aspects of being a good programmer.
With examples in Python and Mathematica.

The Art of Productive Laziness (Peter Taylor)

90 mis

Progress isn't made by early risers. It's made by lazy men trying to find easier ways to do something. Robert Heinlein

Learn about the art of productive laziness with The Lazy Project Manager; understanding what is meant by the 'productive lazy' approach to Projects (and life) and learn how to apply these lessons 'to be twice as productive and still leave the office early'. The session will cover the definition of productive laziness, the science behind the theory (yes there really is some), and will share some personal learning experiences that led to the creation of 'The Lazy Project Manager'. In addition the audience will be led through the three key project stages, one of which the 'lazy' project manager works very hard in and the second they should be in the comfortable position of enjoying the 'comfy chair' safe in the knowledge that the project is well under control.

A specific focus will be made on the third area, project closure, which can be done so much better with very little effort but with a significant value add for all 'would be' lazy project managers.

The Requirements 10 step (Allan Kelly) {Slides}

90 mins

Whatever method of development is being used someone needs to decide what is needed before the code gets written. For Agile teams this more important than ever because requirements constantly change and time is limited. Indeed the next challenge for Agile methods is to improve the quality, and reduce the quantity, of what is being asked for.

In this presentation Allan Kelly will present a 10 step model and supporting tools for teams to improve the "what" of software development.

Thinking About Code (Thomas Witt)

90 mins

This session will look at the engineering aspect of writing code. There is more to shipping a piece of software than mastership of a language or a technology. As a result there is an abundance of advice, rules, coding guidelines and methodologies out there vying for your attention. Probably not surprisingly this session will offer another set of those. More important though this session will look at how to best pick the rules and methodologies you are going to follow. It will make an argument that it is more important to understand why and what matters than to pick the latest and greatest methodology.

User-centred design in agile development (William Hudson)

90 mins

There are some important psychological issues that affect the way that technologists think about and understand users. In this controversial talk, William Hudson presents his research into the implications of empathizing-systemizing theory and how development teams can work together to produce great experiences for users while working within Agile constraints. Topics include the technology chasm, empathizing-systemizing theory, personas, persona-weighted feature matrices and design maps for communicating user experience design between team members.

Using xUnit As a Swiss Army Testing Toolkit (Chris Oldwood)

90 mins

Modern Unit Testing practices act as a conduit for improved software designs that are more amenable to change and can be easily backed by automation for fast feedback on quality assurance. The necessity of reducing external dependencies forces us to design our modules with minimum coupling which can then be leveraged both at the module, component and subsystem levels in our testing. As we start to integrate our units into larger blocks and interface our resulting components with external systems we find ourselves switching nomenclature as we progress from Unit to Integration testing. But is a change in mindset and tooling really required?

The xUnit testing framework is commonly perceived as an aid to Unit Testing but the constraints that it imposes on the architecture mean that it is an excellent mechanism for invoking arbitrary code in a restricted context. Tests can be partitioned by categorisation at the test and fixture level and through physical packaging leading to a flexible test code structure. Throw in its huge popularity and you have a simplified learning curve for expressing more that just unit tests.

Using scenarios from his current system Chris aims to show how you can use a similar format and tooling for unit, component and integration level tests; albeit with a few liberties taken to work around the inherent differences with each methodology.

Web Services versus REST (Nico Josuttis)

45 mins

In the modern B2B and SOA world there establish two different protocols as Standard: Web Services and RESTful HTTP. In this talk we compare both to try to come to a final conclusion, which one is better (OK, which one is better in which context).

What is in a good contract? Designing interfaces for distributed systems. (Schalk Cronje) {Slides}

90 mins

SOA is still a big word, but standards are matured since the early days. There is a lot of good things happening in the SOA world, but as every Tom, Dick and Harry put an interface in the cloud, so has the many ill-designed contracts multiplied. The session will mostly concentrate of using SOAP as the message transport medium, but will look as various message patterns including asynchronous messaging. I shall highlight how good design contract techniques that were taught to people for code also applies to contracts in a SOA world and the big impact contract-first via code-first have on distributed systems. Other highlights include interoperability and code-generation issues, use of SOAP headers, use of WS-Addressing, extensibility and service governance. Beware, naked XML will be shown during the presentation.

What's Wrong With Requirements? (Tom Gilb) {Slides}

90 mins

Requirement methods are woefully inadequate for today's critical and complex systems. There seems to be wide agreement about that. We know what to do, if we want to, and some corporations have done so, some projects have done so, some developers have done so, some professors have done so: but when is the other 99.99 % of requirements stakeholders going to wake up and do things to a decent standard? I have personally seen several real projects where the executives involved allowed over $100 million to be wasted on software projects, rather than ever changing their corporate practices. $100 million here and there, corporate money, is not big money to these guys! Reminds me of politicians sending millions of soldiers to fight for glory. Reminds me of Wall Street 2007. However, if there be some executives or Boards, governments, or professors or consultancies, who want to try to improve things with project requirements - we know what to do about it.

What's new in Java 7? - An Overview of Core Java Features Released with Java 7 (Angelika Langer)

90 mins

Abstract: The tutorial gives an overview of language extensions, additions to the core Java libraries, and relevant changes in the JVM that were released with Java 7. Among the new features are automatic resource management (ARM), improved exception handling ("multi-catch"), closures (Project Lambda), concurrency updates (Fork- Join / Parallel Arrays), type annotations for defect prevention (JSR 308), a revised file API (NIO2), modularity support (Project Jigsaw), and a new garbage collector ("G1"). Some of the features have been controversally debated in the Java community for years. The tutorial will explain what the ado is about.

Note: Since Java 7 has not yet been released (release is scheduled for September 2010) and due to the fact that Oracle tends to operate behind closed doors it is still unknown what exactly will be part of Java 7. Accordingly the above abstract might be subject to change.

Audience: Java developers

Prerequisite: basic Java Knowledge

Will the Real OO Please Stand Up? (Kevlin Henney) {Slides}

90 mins

OO means different things to different people, but they normally focus on defining terms such as encapsulation, polymorphism and inheritance, and talk about data abstraction, abstract data types and so on. In this talk we take a look at a particular perspective of OO that draws on a strict notion of types and follow it through to see what this means in practice for OO programming in general. Some common recommendations are reinforced, some others are questioned, but every programmer using an OO language will get a new insight into how to work with objects. It turns out that it is even possible to do OO in Java, C# and C++!

Worst practices for creating domain-specific modelling languages (Juha-Pekka Tolvanen)

90 mins

All too often, the growing community of language developers have had to fly by the seat of their pants: little material has been available that would teach them how to create a good language. Industrial books give good background for why we need such languages, academic research offers theories and analysis of them, but both categories mostly omit instruction on how to build your own language. In this session we describe a number of worst practices of modelling language creation - identified by analyzing over 70 industry cases. The sample is relatively broad, spanning 15 years, four continents, several tools, around 100 language creators, and various domains.

Writing Software for Women: What do women want? (Emily Winch) {Text (PDF), Slides}

90 mins

Women make up a large proportion of software users, but a tiny and decreasing fraction of the people who make and sell software.

Does being female make a difference to the way people use software? Can the software industry change the way we do things to make our software more useful for women? Would that be sexist? Would any men want to buy our software afterwards?

In this talk we discover the different priorities that men and women have when dealing with software. We wonder whether improving software usability for women would make it easier or harder for men to use it. We discuss ways that women can be made to feel more welcome in the communities that surround our software. Finally we spend some time on the thorny issue of whether talking about differences between the sexes can be productive at all, or whether it just serves to perpetuate outdated stereotypes.

Writing web UI in Test-first fashion with GWT (Uberto Barbini) {Slides}

45 mins

We always do TDD on the server side of our application. When it comes the time to write the client UI part, we are at least sure the backend is sound so we can concentrate on frontend bugs and quirks only. Recently we tried with some success to use strictly TDD approach on the client part too. This is leading to much better client code but also to several problems and compromises. In this session we'll present the current status of our tries.

You're Going To Have To Think! Why [Insert Algorithm Here] Won't Cure Your Calculus Blues. (Richard Harris)

90 mins

We have travelled far and wide in the fair land of computer number representation and have everywhere seen the unmistakable scorch marks that betray the presence of the dragon of numerical error. No matter where we travel we are forced to keep our wits about us if we fear his fiery wrath. Those who take sport in the forests of IEEE 754 floating point arithmetic have long since learnt when and how the dragon may be tamed and, if we seek to perform mathematical computation, we would be wise to take their counsel. In this session we shall take it as read that floating point arithmetic is our most effective weapon for such computation and, whilst considering numerical approximations of differentiation, we shall learn that if we wish to wield it effectively we are going to have to think!

Sponsored Sessions

Creating A Brand New Product Using Scrum And Agile Techniques (Red Gate Software) {Slides}

60 mins