Friday, 21st April
09:30
C++0x, Concur, and the Concurrency Revolution
A concurrency revolution is underway, as nonconcurrent applications will no longer exploit the continued exponential performance growth in modern mainstream CPUs. Unfortunately, none of today's mainstream languages and environments deal well with concurrency. This talk summarizes the issues involved, and gives an overview of the Concur project. Concur aims to define higher-level abstractions for today's (imperative) languages with the goal of letting developers write correct and efficient concurrent apps with lots of latent parallelism (and not lots of latent bugs) that can be mapped to actual hardware at run time to reenable the free lunch.
11:00
Double-Checked Locking, Threads, C++ Compiler Optimizations, and More
The Double-Checked Locking Pattern is a common approach to efficient lazy initialization. Unfortunately, it's not reliable in C++ in threaded systems, it can fail for different reasons in uniprocessor and multiprocessor environments, and there's no portable way to make it reliable. Every C++ programmer needs to understand why this is the case, because it affects the very core of software development: code generation and program execution. This talk takes a deep look at code generation, compiler and hardware optimization, sequence points, "observable behavior," the significance of "volatile," memory coherency problems, and memory barriers. It concludes with suggestions for C++ programmers who want the efficiency of lazy initialization, but who value correct program behavior even more.
Retrospectives - Project Success with continuous Course Corrections
Retrospectives are a basic requirement for an agile approach. With the help of retrospectives you will be able to detect problems early and make corrections in an easy manner - both is required for the success of your project. In this session you will learn concrete retrospective techniques, the different kinds of retrospectives and when to apply retrospectives in order to be successful.
Effective Version Control
It's surprising how many software shops fail to use source control, employ a pathetic source control system, or don't use their source control tool to the best of it's capabilities.
It's time to address this!
Version control is the staple of a robust and secure development process. It’s not rocket science, but it does require some careful thought and more than a little discipline. There is an art to managing revisions of your codebase well, to maintain release versions of your products, to structure a repository well, and to administer it well. These stem from the sensible version control practices we'll look at in this talk.
Who should attend?
Practicing programmers who want to know how to use their version control tools better, and how to manage their code well.
Development managers who want to know how to save time, manage their codebase safely, and make more effective time of their coders.
What's covered?
By the end of this talk you will have learnt some practical tips and processes to improve the way you manage your source code. You'll leave with skills to improve your project's code management, and able to advise a company-wide source control policy.
We'll cover:
- Basic version control principles
- How to deploy a version control system
- Good repository structure
- What files to version control
- How to manage multiple lines of code development
- Sensible strategies for tags/labels/branches
- How to code well with a version control repository
- Making safe source code releases
- Automation
- Repository administration
Java Script ... but only with Milk and Sugar
The session will give an introduction to JavaScript object oriented programming and modularization. It will show how OOP works in JavaScript and how one can utilize the language to simplify the task of defining and using classes. It will also show how one can add packages/modules features to JavaScript which are not directly supported by the language.
Putting it all together and adding a useful module library we end up with jsolait (JavaScript o Lait).
The session will give an introduction on how to build and use jsolait's modules with an emphasis on client server communication(AJAX) for web applications. It will also cover some protocols like XML-RPC and JSON-RPC.
Intended audience: webapplication developers, developers interested in client-server communication for webapps.
Evolution of C++
The Evolution of C++ Track will consist of a number of presentations relating to the current (at the time of presentation) plans for the next version of C++ (code named C++0x and currently aimed at final release in 2009, which means that all the major parts will be in place by autumn 2007 at the latest)
There will be a report on the changes and additions that have already been agreed on and either edited into the Working Draft (Paper) or about to be.) In addition there will be a presentation on the subject of Concepts (this is currently planned to be given by Dietmar Khuel). At least one other major topic will be included but in order to keep it topical we will be delaying the decision as to which until close to the event.
14:00
A Design Rationale for C++/CLI
In this talk, the lead architect of C++/CLI gives a summary of the design goals and rationale for C++/CLI, to be followed by panel and audience Q&A of the presenter. The talk will consider the requirements and several major design alternatives for a number of specific features, chosen as representative examples that cover most CLI feature areas. It will also include answers to some frequently asked questions about C++/CLI. Attendees are encouraged to browse at least the Overview and FAQ sections of the paper "A Design Rationale for C++/CLI".
Understanding Security With Patterns
Security is a major problem of the software industry as was OO design in the early 90s. Design Patterns brought OO design from black art to mainstream practice. We hope Security Patterns can be a similar success. They make discussions and design of security easier with common names for concepts and allow more conscious decisions. This tutorial introduces the current work on security patterns: what they are, where they come from, and what you should expect. Security Patterns are demonstrated by some examples (different from last year's ACCU) from the new book "Security Patterns".
Coding guidelines: Do they deliver any benefit?
While relatively few people have been killed by faults in software, the fear of such deaths has resulted in a growing number of organizations adopting coding guidelines which they hope will mitigate the possibility that the software they sell will injury their customers.
This talk will describe a process for evaluating the cost/benefit of coding guideline recommendations. It will use this process to evaluate several commonly cited guideline documents. The talk will conclude with a discussion of the various industrial groups currently working on guidelines for software intended for use in high integrity applications.
Intended audience: Software developers wanting to produce reliable software.
Agile development and prototyping with Ruby and Rails
The Ruby language has taken the development world by storm. Its combination of clean, object-oriented syntax (everything is an object) coupled with Perl-like platform independence and inline text processing power make it a useful tool both for writing small utilities and as a rapid prototyping language. The popular web framework, Ruby-on-Rails, allows for easy development of highly-functional web applications.
This session will explore these aspects of Ruby, namely for utilities, prototyping and web development. We will also discuss issues such as scalability and deployment.
Intended audience: experienced developers who are curious about what Ruby has to offer, and want a fair appraisal and introduction without all the hype.
C++'s Concept of Concepts
Although templates are a great tool for the creation of flexible software, they suffer from several sever problems, e.g. incomprehensible error messages when using them incorrectly. The representation of a template's requirements in the form of concepts will solve several of these problems. This talk will first give a brief review of generic programming fundamentals before introducing the underlying ideas of concepts and presenting the two currently competing proposals for the introduction of concepts into the language. It will also show how error reporting based on concepts could look like and how concepts could ease the development of templates.
16:00
The Keyhole Problem
Software too often imposes gratuitous restrictions on how we see or interact with the world — forcing us to experience the world through the keyhole of a door. The Keyhole Problem arises every time software artificially restricts something you want to see or something you want to express. If you want to see an image, but your image-viewing software artificially restricts how much of that image you can see at a time, that's the keyhole problem. If you want to specify a password of a particular length, but your software says it's too long, that's the keyhole problem. If you want to type in your U.S. telephone number, but your software refuses to let you punctuate it in the conventional manner with a dash between the three-digit prefix and the four-digit exchange, that's the keyhole problem. This talk — which applies to software written in any language — discusses what "keyholes" are, why they are worth caring about, and suggests ways to design and implement software containing as few keyholes as possible.
Gumption Traps: Debugging Team Motivation
Rachel Davies, Ivan Moore, Duncan Pierce
Motivation is possibly the most important factor for the success of any software project. In "Zen and the Art of Motorcycle Maintenance" Robert Pirsig describes Gumption Traps; things that sap motivation, such as not having the correct tools. This workshop introduces participants to "Systems Thinking" to help analyze Gumption Traps that they have experienced, and identify possible ways to combat them. This session is for software developers, managers and coaches who would like to identify and avoid gumptions traps for themselves and their teams.
Intended audience: This session is for software developers, managers and coaches who would like to identify and avoid gumptions traps for themselves and their teams.
Project Saving Debugging Tricks and Tips
Your aim may be to write perfect code without any bugs. For some that may be possible, especially for ACCU members! However, not everyone is as good at coding as ACCU members and there is a lot of broken code out there. While you may be able to rewrite it, or find the bugs by inspection, that is too costly. You will learn a number of techniques that make the debugger sharp tool for finding the bugs that kill your code. Topics covered include, crash dumps, symbol servers, resource leaks, trapping memory tramples, stack decoding, knowing when the debugger is not telling the whole truth and making it tell the truth.
Audience: Anyone that has to deal with less than perfect code. If people look to you to fix their bugs, then you need to attend.
Several Species of Small Capable Programs Gathered Together on a Disk and Grooving with the JVM
Till recently it was assumed that the JVM was just the vehicle for executing Java programs. However with the re-emergence of dynamic languages (e.g. Python, Ruby, etc.) a search has been on for a dynamic partner to Java executing on the JVM. Jython and JRuby do not have the right object/computational model to be the right solution. Groovy is a language that takes many of its ideas from Ruby but is a language for manipulating Java objects running on the JVM. Unlike Beanshell which is really just directly interpreted Java, Groovy is a fully fledged dynamic programming language that translates to JVM bytcodes.
Groovy has many, many interesting features that make it ideal for use in realizing dynamic systems where a JVM is being executed. Some current uses include Web-server based systems, scripting Microsoft Office applications, adding dynamics to Wikis, testing Java systems, etc.
The core language features of Closures and implicit use of reflection add a dimension to JVM use that Java cannot provide on its own. Groovy is currently developing as a JSR (JSR 241) and will soon be an integral part of Sun's Java Platform.
This session is an introduction to this (relatively) new language and some of it interesting capabilities.
Advertisement
