Thursday, 20th April
09:30
Software Development: a social activity with technical practices
While the importance of ‘people factors’ in software engineering has been recognised for over 25 years, few specific factors, and their impact on software engineering, have been identified. ‘People factors’ covers a wide and diverse set of issues. In this talk Helen focuses on social factors, i.e. factors that arise from the various interactions that need to take place in order to develop software. She draws on three different studies she has conducted over the last 10 years to identify three specific factors and their impact on software development.
11:00
When C++ Hits the Hardware
This class addresses two issues of particular interest to developers of embedded systems, but the material should be of interest to everybody working with C++. First, it examines the parts of programs that don't change during execution, i.e., the parts that could be burned into ROM. Second, it describes an elegant approach to modeling memory-mapped IO that provides a natural interface for users, great flexibility for implementers, maximal efficiency (in both size and space), and compile-time prevention of common client errors. The technique is based on a combination of templates, classes, inline functions, placement and custom new (without requiring dynamic memory allocation), references, bit operations, volatile memory, private member functions, and reinterpret_casts, but the generated code should be as good as that produced by the most hardcore hardware hacker.
The Django Web Application Framework
The Django web framework was announced publicly in August 2005 after two years production use and has immediately moved to the forefront of Python web development. Many are claiming that it is Python's answer to Ruby on Rails, only more elegant. This talk will teach you to use Django as well as comparing and contrasting its approach and design with other web frameworks.
Embedding Domain-Specific Languages in Java and C#
It is said that LISP programmers first write a language then use that language to write the application. We have found that even in popular, static languages code tends to evolve over time to have a similar structure. Domain specific languages emerge over time as a result of continual refactoring. However, the idea that programmers are language designers is not well recognised in the static language communities where most of us work.
We believe that a program's domain-specific languages should be made explicit as part of the development process, so that they are visible and can be made easier to use. Often this has to be done within the programming language of the application, rather than as a separate language. These techniques should be in the toolbox of every mature software professional.
This talk will explore how to design and implement domain-specific languages within conventional languages such as Java and C#. In particular, we will demonstrate how to work within the syntax and type system of the underlying language. As a motivation, we will describe the evolution of the jMock library (http://www.jmock.org), for which we developed an embedded language to express constraints on an object under test and compare it to nMock, an equivalent library in C# and other experiences with the techniques we describe.
Distributed Collaboration
In today's development environments, project teams can span the globe. They are also often formed of members from multiple organisations. How do team members in multiple locations collaborate securely and effectively?
This lecture will take real world examples and discuss the tools and methodologies employed to successfully collaborate in a distributed development environment. Topics covered will also include project management and change management.
11:45
Easy web application development with CherryPy
Over the last 6 months CherryPy has emerged as one of the easiest way to develop web applications in Python. It offers the most "pythonic" way to publish objects to the web. CherryPy can be used directly for simple web applications or with a higher-level framework such as TurboGears for more complex applications. This talk will show why it is so easy to develop web applications with CherryPy. It will also explain when to use CherryPy directly or when to use a higher-level framework like TurboGears, based on CherryPy. To do this we'll take a few case studies of some public sites/intranets that have been built with these tools.
13:00
Using Win32/WinFX Integration to Light-Up on Windows Vista
(Microsoft sponsored session)
David Burggraaf
Wondering how to integrate Windows Presentation Foundation (formerly code named "Avalon") for rich UI, Windows Communications Foundation (formerly code named "Indigo") for flexible communication and other great Windows Vista features into your application? Want to see what's really involved in making your software "light up on Windows Vista?" Using the Windows XP version of the Internet Hearts game as a case study, this session highlights strategies and best practices in augmenting large Win32 code bases to incrementally take advantage of new WinFX and Windows Vista specific functionality.
14:00
Working with C++ as if Unit Testing Mattered
The practice of Test-Driven Development (TDD) has started to spread throughout the industry. Teams that have adopted it have noticed that the test coverage it provides makes code change easier and more deterministic. Unfortunately, TDD has not become popular yet in the C++ community. There is a lot of existing C++ code that is nearly impossible to test at the unit level. The problems include (but are not limited to) overly long functions, embedded static references, embedded object creation, lack of abstraction, and static construction dependencies. In this hands-on tutorial, you will learn a series of techniques that you can use to systematically and safely break dependencies to get C++ code under test. We will also discuss the genesis of some of these problems and ways of avoiding them in the development of new code.
Code exercises will be available via USB stick in a form acceptable to GCC and Microsoft compilers.
Typeless Functor
The Typeless Functor is a new and quite unusual C++ technique. Also, perhaps because of the difficulties implementing it, an underrated one. But a deeper examination will reveal ideas that are known and used in other places:
- deleter
- scope guard
This concept has been also employed by Jonathan Turkanis when designing dynamic_move_ptr. Futhermore, it could be used to improve deleter support in unique_ptr (being proposed into TR1 by Howard Hinnant, together with other stuff that nicely consumes move semantics proposed with rvalue-reference into C++Ox - see WG21 paper N1771).
The whole idea is to encapsulate a function call together with its arguments (or pointers to arguments) in an object. The important point is that the type of the object does not reveal anything about the encapsulated function, not even type of its parameter(s). The other point is that such an object is extermely cheap to build, use and copy (thus no dynamic allocation), and the only thing that might be revealed is the memory footprint of such an object.
Currently there is no class (nor class library) that would provide such functionality, the trouble is there might not be any even at the time of talk - but still, the technique could be useful for those who (sometimes) find boost.function little limiting or costly.
Intended audience: intermediate/advanced C++ programmers interested in another "cool" (meta)programming technique. I will be very interested on input from the audience, as this technique might actually give birth to something that could be proposed into TR2 (scope guard in a C++ standard library, anyone?).
Only the Code tells the Truth
This workshop will analyze the sentence "Only the Code tells the Truth" and try to collect from participants their impression and implications of it. It can be read both as an explanation of and as a guidance for writing of programs. The goal of the workshop is to collect aspects of such guidance for programmers that help them writing code that actually tells useful things about itself. In the opinion of Peter, getting that sentence and its implications into a developers subconciousness will lead to better software, but he is willingness to hear opposition in the workshop.
Audience: experienced developers, consultants and teachers of the software profession interested in discussing value systems underlying good software.
Experience of a distributed software project for protein science
The project is based in a government research laboratory near Warrington, where there are three developers. There are collaborators in Dundee, York, Oxford, Cambridge, Paris, Amsterdam, and Grenoble. Principal customers are in twelve UK universities.
The presentation will use this experience to discuss the human aspects of collaborating at a distance to produce software, including:
- customer relations and requirements elicitation
- the architectural process in a distributed team
- forming a common assessment of progress
- challenges in involving all stakeholders in risk assessment
- mentoring in a distributed team
- the role of work culture in creating and resolving conflicts
- challenges in project start-up
- appropriate use of authority in software development
It will contrast the academic and commercial environments, mainly in order to highlight the common challenges faced by software development projects whatever the milieu.
Intended audience: Team leaders, project managers, software architects, and developers involved in distributed (virtual/multi-site/non-collocated) projects.
14:45
Metadata and models in Python
If you provide a rich central 'schema language' for your business objects, you can get a great deal more functionality for free. This includes rich validation for web submits, flat file and XML persistence, autogeneration of the correct GUI widgets, and automatic documentation of object models for business users. These are classic 'cross cutting concerns' which are helpful to all whether you are dealing with a polygon in a graphics editor, a customer contact record, or an option pricing model.
There have been many such patterns in Python libraries but the advent of metaclasses has simplified them; however the most popular examples are tied to the database domain. The talk will present a metadata framework for declaring objects which is not tied to databases (although it can make use of ORMs); as well as comparing and contrasting powerful metadata frameworks such as SQLObject, Django.core.meta and reportlab/graphics. It aims to provide practical tools to all Python developers as well as food for thought for framework authors.
Herding Hedgehogs
Most case studies are of successful projects, but it is also possible to learn lessons, albeit painful ones, from projects that went badly wrong.
This project featured a programmer in Atlanta, Georgia, another programmer in London, a sysadmin in New York, a graphics person in Orlando, Florida, a storyboard person in Boston, Mass, and a technical writer in London. No project manager and no proper group collaboration tools.
Throw into the mix an AOL that couldn't make up its mind whether it actually wanted online games, plus a dash of dot com mania, and you have a recipe for a truely awesome disaster!
This talk will look at what happened, why, and what could have been done differently.
16:00
Financial Programming in Python
The Python language has been an under-the-radar favourite on the financial community for many years, with its emphasis on rapid prototyping and construction of models, and on acting as the glue which can bind other systems together in an industry where change is a constant. Recently it has come above the radar and a number of practitioners are collaborating to release a best-of-breed framework of pre-built components in this domain.
Simple, Simplest, or Simplistic?
Simplicity is a concept that lies at the very foundation of software engineering: simple software is more maintainable, has fewer bugs, has a longer lifetime, etc.
In the last few years, the advent of Extreme Programming and agile methods has made simplicity (e.g., "do the simplest thing that could possibly work") even more fashionable. However, simplicity is an elusive concept, and, very often, people confuse it with the first idea they can think of, producing simplistic solutions that eventually lead to unnecessarily complex software.
The goal of the session is to explore this concept, giving also real-life (good and bad) examples, and stimulate a discussion with the audience about the reasons why we continue to produce unnecessarily complex software, and about what we can do to avoid the traps of simplistic solutions.
Audience: people involved on the technical side of software development
Agile with Offshoring
Outsourcing, Offshoring and Nearshoring are nowadays standard ways for developing software. Agile software development is meanwhile recommended - even from the Standish Group - as a promising development approach. In this session we would like to share our experiences in the area of agile offshoring and point out the best and worst practices.
Advertisement
