Wednesday, 19th April
09:30
The Future of Python
The next major version of Python, nicknamed Python 3000 (or more prosaically Python 3.0), has been anticipated for a long time. For years Guido has been collecting and exploring ideas that were too radical for Python 2.x, and it's time to stop dreaming and start coding. In this keynote he will present the community process that will be used to complete the specification for Python 3000, as well as some of the major changes to the language and the remaining challenges.
11:00
Five Considerations in Practice
The 2005 keynote, "Five Considerations", introduced five considerations for software development: economy, symmetry, spacing, visibility and emergence. (The pub origins of the considerations also received a mention.)
This session looks beyond the concepts to the practical consequences, giving examples of how each of the considerations can influence code and practice, and how they support or oppose one another. The practical applications touch on many topics, ranging from identifier naming and control flow to dependency management and development process.
A Roundup of PyCon
A roundup of all the key developments from PyCon 2006, which takes place shortly prior to ACCU 2006.
Exploring Interfaces - A C++ Perspective
Classes and functions should offer interfaces that make them both easy to test and easy to use. That much is obvious. What is less obvious is how to achieve this. Modern C++ is a rich and expressive language, and many factors come into consideration.
Some of these factors are consequences of the design of the language: for example, a certain level of exception safety is difficult (or even impossible) to programme for, if the class/function interfaces being used have not been designed with this in mind. Other factors are a consequence of software engineering practice - for example, encapsulation and separation of concerns - in a more general sense.
This presentation is aimed at intermediate and advanced C++ developers, and aims to discuss some of these factors and how they influence interface design in modern C++.
Intended audience: Intermediate and advanced C++ developers.
XPath2, XSLT2 and XQuery - The 3 Legs of XML Searching and Transformation
You can search an XML document with XSLT2 and you can style an XML document with XQuery. No wait ... no, that's right. And the other way round too. In that case, do we need both? Can we bin one of them? Is it just an accident of corporate politicing that they both exist?
In this session I'd like to sprint through XSLT2 and the new features it adds to the existing XSLT spec. That will necessarily lead to an examination of XPath2, the expression language it incorporates. Since XPath2 also forms the basis of XQuery, I obviously can't ignore that, and intend to spend a reasonable chunk of time comparing XSLT2 and XQuery, looking at their similarities, differences and intended usage.
Since query and transformation languages are rarely used in isolation (when was the last time you wrote a naked SQL query?), I also want to look at using XPath2 and XSLT2 from a host language (probably Java, since it currently has the best tool support).
Intended Audience: This session assumes a degree of familiarity with XML and at least some idea of what XSLT is about.
Applications with GUIs - programming and design
It is a common misconception, reinforced to a large extent by designers of GUI libraries, that GUIs are designed on the back of an envelope in the pub, that the resulting design is fixed, and that all programming thereafter resolves around the designed GUI.
You can do it that way, and a lot of people do so - something which goes a long way towards explaining why a lot of programs have such shambolic user interfaces. It also explains why the programs have to be completely rewritten when they are transferred (the term porting would be a misnomer) to a new operating system or interface library.
This talk will discuss the basics of user interface design, and how to keep the 'business logic' separate from the GUI code, so that users can work naturally with the application and porting to new interfaces is smooth and easy.
11:45
Error Handling With Recovery
Python's error handling is a much more flexible than that of languages like C -- which essentially don't have any error handling. However Python's exception lacks some of the flexibility offered by the facilities of languages such as Common Lisp or Smalltalk. This talk will talk about error handling in general, some of the extra capabilities of Common Lisp systems and how they might be implemented and used in Python.
14:00
Healing the Architecture
Having a job title is an insufficient qualification for being a software architect. Seasoned architects have learned how to transition the architecture vision into the projects' reality. They are able to detect problems before they have become critical, and know a variety of different measures appropriate to the situation at hand.
This tutorial gives the participants a new way to look at software architecture, which is appropriate beyond the up-front architecture especially for projects in crises and agile development. The knowledge of early symptom recognition and selection of a reaction can be collected in the form of diagnoses and therapies. The tutorial covers problems related to organization and process, design and implementation, role and attitude in a mixture of lecture and interactive exercises. During the exercises, attendees have the opportunity to relate their experiences to already known and proven solutions, and to contribute to the body of knowledge.
PyQT 4
PyQT4, the Python bindings for QT, is scheduled for release in early 2006. This is the first release based on QT4, which allows use under the Gnu General Public License on Windows, and this is expected to considerably broaden the interest in PyQT development.
The talk will be split into 3 main sections: "What is PyQt?", "Differences between PyQt3 and PyQt4" and "An introduction to developing with PyQt4"
How Metacode and Compile-Time Reflection Could Change Your View of C++
Though it might not be in the next version of the C++ standard, compile-time reflection is a hot topic in the C++ community. Daveed Vandevoorde's metacode proposal offers the potential for a complete new approach to C++ system design. An extended version of that proposal could be used to provide additional language paradigms like logic programming, aspect-oriented programming or contract-based programming, to allow for more choices with multi-paradigm design. And compile-time reflection can be used to ease the implementation of and provide more usable interfaces to libraries that provide support for e.g. database access, multi-processing support or advanced debugging utilities.
This talk presents some ideas how new runtime language features might be implemented using compile-time reflection. As there is currently no detailed proposal for metacode or compile-time reflection, some requirements for a specification are presented that are necessary to implement those features.
Intended audience: This talk is for software developers and system designers. A good working knowledge of ISO C++ is helpful, but not required.
Data beyond its application
This session explores some database concepts and how these are important to the design of applications and the data they generate.
The information produced by the systems we write is important to the organisations that use them, it is important for us as developers to understand what questions a organisation may want to ask of the data they have. The general term for these questions, the analysis performed and the systems providing the answers is business intelligence.
There are a number of database technologies and techniques that form the basis for business intelligence and this session provides an introduction to these, for example OLTP, OLAP and data warehousing. There are products specifically written for business intelligence and the basis on which these operate is explored. Finally the session explores how to design our systems so that we better support analysis of the information our systems produce.
Intended Audience: Anyone who is involved in the development of applications or systems that persist data and who are interested in the techniques used to allow organisations to analyse this data.
Multithreading 101
This talk is aimed at the threading novice: those that have had little or no experience in writing multithreaded applications. The talk is also programming language neutral as the general concepts should be applicable to all languages. I'll be covering what the main threading primitives are and where you use them. Perhaps more importantly I will look at why you should go multithreaded in the first place. Also I'll show examples of some of the common uses of threads and how the threading primitives are used to manage synchronisation and communication. There will be some audience participation with the intent of following the adage from Confucius - "What I hear, I forget. What I see, I remember. What I do, I understand."
16:00
SOA - From dust to dawn
SOA (Service Oriented Architecture) is hype.
According to Gartner, by 2008, SOA will provide the basis for 80% of development projects. However, we are seeing all the effects of a hype of a very new topic. Especially, there is not even a common understanding about the core terms such as "SOA", "service", and so on.
In this talk, Nicolai Josuttis tries to separate the SOA hype from SOA reality. As a team leader of the realization of a SOA at a world-wide mobile phone company, he knows about the difference of theory and concepts on one hand versus reality and practice on the other hand. He will present some often not told important aspects based on his experience. As a result you will have a better understanding about what SOA really is about.
PyPy - a progress report
PyPy is an open source, EU funded research project aiming to produce a high-performance and extremely flexible implementation of Python. This talk will give a high level overview of the architecture of PyPy before concentrating on the opportunities and challenges provided by the very high level approach we have taken.
Managing Generative Programming
You might have heard about generative programming or seen the benefits it can render. Now you would like to apply it in your organisation. How do you sell this to your management or your team? What are the skills and knowledge required? Can GP contribute to knowledge management? This is a session where I try to help you with your questions, but at the same time try to learn about what problems other people have experienced. This will be a slide-driven interactive session.
Audience: Those interested in the software process related to GP instead of the technical details
Cross-Platform Issues With Floating-Point Arithmetics in C++
The C++ standard does not specify a binary representation for the floating- point types float, double and long double. Although not required by the standard, the implementation of floating point arithmetic used by most C++ compilers conforms to a standard, IEEE 754-1985, at least for types float and double. This is directly related to the fact that the floating point units of modern CPUs also implement this standard. The IEEE 754 standard specifies the binary format for floating point numbers, as well as the semantics for floating point operations. Nevertheless, the degree to which the various compilers implement all the features of IEEE 754 varies. This creates various pitfalls for anyone writing portable floating-point code in C++.
This session covers the following topics:
- Floating-point types in C++
- The binary representations of IEEE 754 floating-point numbers
- Special numbers (Not a Number, Infinity, signed zero)
- Gradual underflow and denormal numbers
- Rounding modes, exceptions and flags
- Issues not addressed by the IEEE 754 standard
- Practical floating-point programming
Attendees of the session will learn about the intricacies of working with floating-point arithmetics in portable C++ code.
Intended Audience: C++ developers who want to learn about the intricacies of working with floating-point arithmetics in portable C++ code.
16:45
Lightning Talks
Apply testing patterns to the development life cycle
If you think that writing unit tests is often tedious, unrewarding, and even boring, you are not alone. Most developers would rather write code "that does something." However, writing unit tests became an obligatory part of the software development process for a good reason - improve code and prevent bugs.
This session explains how developers can apply coding standards and unit testing to improve their code and prevent the number of problems they need to identify, diagnose and fix over the course of the project.
The first half teaches you how to apply coding standards to prevent errors related to code functionality, security and performance. The second part focuses on how you can extend traditional unit testing to expose reliability problems that could lead to instability, unexpected results or even crashes or security vulnerabilities.
Finally, we will discuss how these test cases can be leveraged to build a project-wide automated regression system that runs in the background each night and immediately alerts the team when code modifications or additions break previously verified functionality.
Threaded Programming with C++
We often see C++ programmers discouraged from using threads in their applications, and for that there are many reasons. The most common pitfalls are in dealing with access violation and faulty memory handling, and for those who deploy their software on different platforms, the numerous differences in native thread support don't help either. C++ programmers tend to steer away from threads, preferring complicated single-threaded logics over a perhaps cleaner design that uses threads. In Trolltech, we know that threads are a very powerful tool both from the design point of view, and from that of concurrency and performance. The biggest problem for C++ users lies in finding ways of integrating threads properly into their design, and allowing threads to serve as the powerful tool they are, instead of being a hindrance.
In this talk, we will explain and demonstrate the approach Trolltech has chosen for integrating threads into the Qt C++ library. Qt provides high-level classes for running a thread, using mutexes, reader-writer locks, semaphores and condition variables, as well as a thread-local storage management abstraction.
To simplify data access in threaded code, the container classes have become thread-aware by use of atomic assignment and shallow-copying. This allows some simple, yet powerful techniques – which we will demonstrate – that in many cases can completely eliminate the need for locks for shared data structures.
In addition, we will go through some of the implementation details that make complex IO classes like QFile, QProcess and QTcpSocket thread-aware. We will also present some of the solutions chosen for inter-thread communication: event posting and signal-slot connections.
Advertisement
