Skip to content





Usability, Accessibility & Misc
New Horizons
Opening by Dr. Dalibor Stys (Director, Institute of Physical Biology, University of South Bohemia), Prof. Proell (FH Hagenberg), and Matthias Kalle Dalheimer (President, KDE e.V.)
Practical Information (laptop rental, location, food, etc.); Dr. Rudi Ettrich, Acadamic and University Center, Nové Hrady
Harald Fernengel, Trolltech AS: KDevelopDavid Faure, Klarälvdalens Datakonsult AB: How to write a Makefile.amTim Jansen: The Knot - A SLP-based Zeroconf solution; Paper
Marc Mutz, University of Bielefeld: Design Patterns (sig), TeX source (sig)Stephan Kulow, SuSE AG: The KDE Build System
George Staikos, Zack Rusin: KaXUL & uXUL
11:10-11:40Coffee BreakCoffee Break
11:40-12:40Tobias König, University of Technology Dresden: Programming with libkabcGunnar Schmidt, University of Paderborn: KDE and Accessibility (sig)Carsten Pfeiffer, Fraunhofer Institute: Aspect Oriented Technologies: Ready for adoption?
14:00-15:00Holger Schroeder, Automatix GmbH: KDE-CygwinGunnar Schmidt: Accessibility and Interoperability (sig)Josef Weidendorfer, University of Technology Munich: Performance AnalysisHavoc Pennington, RedHat, Inc.: D-BUS
15:05-16:05DavidFaure, Klarälvdalens Datakonsult AB: The KTrader mechanismJosef Spillner, University of Technology Dresden: The dynamic desktopAndreas Brandt, University of Frankfurt: My research about KDEMatthias Kalle Dalheimer & David Faure, Klarälvdalens Datakonsult AB: OpenSource Memory Debugging
16:05-16:35Coffee BreakCoffee Break
16:35-17:35Ian Geiser, sourceXtreme: Scripting Applications with DCOPEva Brucherseifer, basysKom GbR: A KDE Usability StudyDavid Faure, Klarälvdalens Datakonsult AB: How to write good network transparent codeGeorge Staikos, Staikos Computing Services Inc.: KWallet; Paper
17:40-18:40Chris Schläger, SuSE AG: TaskJugglerHavoc Pennington, RedHat, Inc.: freedesktop.orgDaniel Molkentin, University of Technology Chemnitz: Kontact the world!, Abstract
19:00-20:00Social Event; includes: Matthias Ettrich, Tolltech AS: Qt: past - present - future (dot story)Matthias Ettrich, Matthias Kalle Dalheimer: The History of the KDE Project; Pictures (25MB)


Workshop: KDE-Qt integration
Workshop: KDE System Configuration
Workshop: Scripting Applications with DCOP
PGP Keysigning Party
Note: For a maximum of flexibility, workshop time and details will be announced at short notice
Talks about AccessibilityGunnar Schmidt<>

Talk 1: KDE and Accessibility
This talk covers both the current state of the KDE Accessibility Project and some general view on accessibility issues within KDE. It will also contain an outline of kttsd and word completion for usage as KDE-wide technologies.
Talk 2: Accessibility and Interoperability
This talk will show an outline of an architecture for adding AT-SPI support(Assistive Technology Service Provider Interface) to Qt/KDE. As there could be applications and assistive technologies both within and without KDE this architecture needs to interoperate well with GNOME's Corba based assistive technology framework.
Aspect Oriented Technologies: Ready for adoption?Carsten Pfeiffer<>
Object Orientation offers strong concepts for functional decomposition of systems. There is a number of requirement types though, that can not be properly encapsulated into classes or functions. The reason for that is, that these often non-functional concerns crosscut the system's structure, leading to a scattered and tangled implementation.
Aspect Orientation aims to provide a solution for this problem by offering a new modularity concept, that allows the extraction of scattered and tangled code fragments into first class entities called aspects [1]. However, the gain of modularity comes at the price of increased complexity. Dedicated tool support to reduce the complexity is therefore crucial for successful emplyoing of aspect-oriented concepts.
In this paper, the concepts of Aspect Orientation are introduced and an overview of state-of-the-art aspect-oriented technologies for C++ is given. A case study will reveal whether these technologies are already suitable for adoption in real-world projects.
[1] Gregor Kiczales, John Lamping, Anurag Menhdhekar, Chris Maeda,
Cristina Lopes, Jean-Marc Loingtier and John Irwin.
Aspect Oriented Programming. In Proceedings European Conference
on Object-Orientated Programming, volume 1241, pages 220-242.
Springer Verlag, 1997.
TalksDavid Faure<>
  • Tips and tricks for debugging (gdb, test programs, valgrind, cachegrind...)
  • How to write a (based on the short talk I gave at the last FOSDEM)
  • The trader mechanism (usefulness, services and servicetypes, querying, debugging).
  • How to write good network transparent code (KURL, KIO, jobs vs NetAccess).
The dynamic desktopJosef Spillner<>
Many KDE applications are extensible in form of plugins, additional texts or images or audio files, or other means. Up to now each application has to define an own way on how to access these additional files. This ranges from requiring the user to download contents over predefined download sites (like to embedded mechanisms as used in KOrganizer.
In 2002, a project named KDEShare was proposed, and an initial implementation was started, which worked essentially but had some design issues, and since some timing issues were involved as well the development on it stopped.
Yet it clearly shows that a unified way of updating contents is needed:
  • many applications, like those in kde-edu, come with a default set of data but offer additional sets (sounds, vocabulary files)
  • some applications rely on fixed host names for their updates, yet a fault tolerant transport is needed, which could be ensured using metaservers embedded in a general resource framework (example: KDE internet radio frontend)

This talk is intended to regain interest in the topic, and to present specific development goals. Application-specific integration will be presented using KParts, application invocation and DCOP calls. Access to metaservers (and how to administrate them) will be part of the presentation. The collaboration with a typical 3rd party KDE project will be shown as well.

KontactDaniel Molkentin<>
In times where KGX is hitting the corporate desktop, it is important to have a groupware enabled personal information management (PIM) client that is able to interact with common groupware solutions such as Kolab and Exchange 2000.
Kontact, a collaborative effort of the KMail and PIM team tries to serve this demand.This talk will give a summary on what has been achieved and what still remains to do. It includes a general presentation of Kontact's features and addresses technical and conceptional details, ideas and plans.
Also Kontact will later on superseed the Kolab client and therefor inherit all its features.
This talk addresses two primary parties:
  • Developers interested in joining the KDE PIM team.
  • Companies that seek out on a native KDE integrated client for Kolab or

Exchange and want to get involved with Kontact development or support the project.
A workshop will be appended on demand, Kontact hacking will take place during the hackfest.
Web Reference:

Programming with libkabcTobias Koenig<>
The KDE address book library
  • General concept of libkabc
  • The API
  • Small example program
  • Advanced usage
  • Implementing resources
Be More Rational: Open Source Memory Debugging and Profiling ToolsMatthias Kalle Dalheimer<>
(Together with David Faure):
This talk will be similar to the LinuxTag talk with the same name, but have a stronger emphasis on KDE development. We will present tools like Valgrind and KCachegrind and show real-life examples and to debug and optimize KDE programs in a time-efficient way.

The History of the KDE Project
(together with Matthias Ettrich)
This talk, given by two participants from "Day One", will present newer KDE developers with some cultural background of "how it all started": Matthias' original Usenet posting, the first pieces of code, the first package, the first CVS server, the famous c't article that got many of
the German developers to KDE, the first KDE conference "KDE One" in Arnsberg, etc.

kde-cygwinHolger Schroeder<>
The kde-cygwin project makes KDE available on Microsoft Windows Operating Systems. Currently the only way to do this is to use Cygwin ( and to use a X-server in Cygwin. This already works fine, but it has some drawbacks: All kde windows are inside a big X window, and not directly on the Windows desktop, and only the X window appears in the Windows-"taskbar". Also the X-server eats performance. So i started to dig into the kde and qt sources and looked for parts, that were X-dependant. Then i started porting the GPL'ed qt for x11 to use native Windows gdi calls. This project can be found at Then i got a commercial Qt license for x11 and for Windows, so i am
not allowed to continue working on the qt-win32 port. i guess i finished about half of it. All the drawing stuff works, only parts of the rest are missing.
So now i am able to take the KDE sources and replace the X-dependant stuff by something that works under Windows or simply comment it out. There is only little functionality in kde that depends on X directly instead of the qt routines. it is mainly the handling of keyboard input (global shortcuts, ...), querying for screen properties ( x11AppDpiX() ... ) and the NETWM stuff.
KDevelop 3.0 presentationHarald Fernengel<>
KDevelop started as an ambitious project to bring an easy to master integrated development environment (IDE) to KDE. The upcomming release of KDevelop is a big milestone for the project. The code is a total rewrite and features a plugin-based language-independent infrastructure. A lot of work has been put into the new version making it one of the largest KDE application currently available.
The presentation will feature developing with KDevelop as well as developing on KDevelop. Main points reach from project generation to handling the project management, version control, debugging as well as handling and customizing the IDE. The focus lies on C++/KDE development, but also touches scripting projects (perl, php, python) and other supported programming languages like ada, java or pascal. A brief overview of KDevelop's structure illustrates how easy it is to extend the IDE with additional features.
  • A glance at the IDE
  • Kicking off a new project
  • Project management with automake, qmake or ant
  • Handling version control systems
  • Debugging
  • Using the documentation browser
  • Extending the IDE

Harald Fernengel, assisted by Roberto Raggi

The Knot - A SLP-based Zeroconf solutionTim Jansen<>
Zero Configuration Networking allows computers and other devices to communicate without any manual configuration. This means that computers and devices on the same network must assign themselves IP addresses, without the presence of a DHCP server. Systems must broadcast their names on the network, and they must be able to announce the services that they offer.
SLP (RFC 2608) is a proposed IETF-standard for a extendable and scalable service location protocol. It can publish information about network services in the form of a URL bundled with a set of attributes. In small networks SLP can work without any servers as a peer-to-peer system. In larger networks one or more servers need to be deployed. Clients will discover and use these servers automatically.
The Knot is an implementation of SLP with a focus on security and extendability. It is implemented in C++ using Qt/TinyQ and comes with a powerful KDE API. Several small extensions allow to use it for naming as well as File Sharing with existing protocols like NFS and
This talk gives an introduction to the concepts of Zeroconf and its implementations with a focus on SLP and presents the Knot. It will be assumed that the listener has basic TCP/IP knowledge.
KWalletGeorge Staikos<>
KDE 3.2 will include a new subsystem for storing sensitive data such as passwords, web forms and certificates in strong encryption containers known as "wallets". This behavior mirrors the behavior of implementations such as Mozilla's Wallet, Apple's Key Ring, and other similar subsystems. It also extendes these concepts by implementing generic storage mechanisms and user interfaces, allowing more complex data to be stored and shared amongst applications as well as allowing the user to easily manage the stored data and control which
applications may access it. This paper will outline the architecture of KWallet as well as discuss how and why application developers should take advantage of what KWallet has to offer. It will include examples of applications presently using KWallet.
Performance Analysis of GUI applications on LINUXJosef Weidendorfer<>
Optimizing performance in a LINUX application is a difficult task using the legacy profiling tools like gprof. Especially in the scope of GUI applications using shared libraries and dynamically opened plugins, these tools are difficult to use and often can't help at all. The result is, that in most cases, performance optimization doesn't happen at all. If there's an obvious performance problem, one has to estimate the location of the bottleneck or resort to handcrafted meassurement routines.
Last year, a tool for instrumenting binary code on the fly was released for LINUX under the GPL: Valgrind. Using its technique first as a memory debugging, its astonishing features and ease of use made it quickly the number one tool in the open-source LINUX community. In contrast, Valgrinds usefullness for program execution analysis is less known, but likewise powerful. It's based on the cache simulation extension "cachegrind", delivering flat profiling on a source line level. But to get a real overview of the performance characteristics of your program, the measured costs have to be attributed to functions or even libraries. Also, you want to see the cost of a function including the cost of all the functions called from there. This is especially important for programs doing the real work in third party libraries with long call chains like GUI applications. Thus, call tracing was added to "cachegrind", resulting in the tool "calltree".
To make use of the huge amount of data delivered by this tool, one needs a powerful visualization, allowing for quick browsing at different granularities ranging from costs of instructions to summed up costs of a whole shared library. A tool delivering these features is KCachegrind, likewise released under the GPL.
In the paper, first I will give an overview of techniques and problems of performance profiling in general, the availability of tools for LINUX, and how the "calltree" extension of Valgrind comes into play here. Then, I will show the requirements for a visualization tool to enable successful performance analysis, together with the featureset of KCachegrind. The paper finishes by showing the typical use case of the toolchain calltree/KCachegrind together with a standard KDE application, and the steps involved for practical use in performance optimization.
Accessing the internals of QObjectsRichard Moore<>
QObjects form the core of Qt and KDE and provide a number of powerful facilities including the signal/slot mechanism, a navigable tree and properties. While the public APIs provided by Qt are enough for many applications, they are not sufficient for all purposes forcing us to use undocumented features to implement facilities such as the Qt-DCOP bridge and the KJSEmbed QObjectProxy class. This paper discusses the undocumented features that were used to create the QObjectProxy, and the difficulties that were faced. It will further discuss what would be required to create a reusable library that conceals these undocumented techniques behind a maintainable API making it practical to use them more widely in creating bindings to other scripting languages or communication systems.
Qt - past - present - futureMatthias Ettrich<>
In my talk I am going to give an overview on how Qt developed in the past, what we at Trolltech have been doing lately and what our plans for the upcoming years are. The focus will be on topics relevant for KDE, such as performance, flexibility, and productivity.
My research about KDEAndreas Brand<>
Respearcher Andreas Brandt from the University of Frankfurt will present his results of a community study condicted at LinuxTag 2002.
Development and Use of Scripting Interfaces for KDE Applications with DCOPIan Reinhart Geiser<>
For almost as long as Unix has existed the shell script has been a integral part of the system. These shell scripts automate and control the system and allow users to encode complex tasks into a simple program. Over the course of evolution of the Unix Desktop the GUI (Graphical User Interface) has made scripting Unix applications much more difficult. One solution to this problem in the KDE (K Desktop Environment)1 project was to use DCOP (Desktop Communications Object Protocol)2. DCOP allows developers to export functionality of their application to be controlled from external applications. This can allow users to automate GUI applications without the need of mouse event recording and custom event recorders.
The two main focuses of this paper will consist of the development of useful scripting interfaces for automation and the use of them from the system shell and python. The first portion will deal with using proxy classes in KDE Libraries to export complex functionality from widgets to the outside world. It will also deal with issues of how to effectively provide interfaces for scripters to use. The second portion will cover how to effectively use dcop interfaces from shell and python. It will also discuss the use of KScriptInterface3 script engines to provide macro facilities to applications.
1) More information can be found at
2) DCOP Information can be found at
3) KScriptInterface Developer information can be found at
TaskJugglerChris Schlaeger<>
The talk is an introduction to the TaskJuggler Project Management Software. It will describe the concept and ideas behind TaskJuggler and then continue with a brief overview of the project description language. Basic topics like task hierachies, resource definitions, resource allocations, vactions, and shifts will be covered.
Using a made-up software development project as an example, the whole workflow of project planing, project tracking and profit and loss analysis will illustrated. Finally report generation and XML exporting will be explained.
The talk is intended for everybody that is involved with planing and tracking of projects. More info can be found at
The KDE Build systemStephan Kulow<>
As technologies like distcc and TeamBuilder came up, it became clear that automake hinders us in getting the best ouf ot these tools. The other problem with automake we have is the need for am_edit to get our developers to code instead of fiddling with Makefiles.
My talk will shortly introduce the way our build system is set up and then I'll go on giving you an idea why unsermake is such a great replacement for automake and why do you want to use it even on single machines.
A KDE Usability Study -- Goals, Results and Future ChallengesEva Brucherseifer<>
KDE's rich and continously growing set of applications as well as its exemplary stability and performance offer the chance for traditional Windows users in administrative and business environments to migrate to Linux not only in the server but especially also in the desktop area.
At the moment we face the beginning of such a transition process and there are already a number of promising examples for it.
However, this situation raises the demand for an in depth comparison of usability concepts between KDE and traditional Windows desktops. Our paper describes activities and results from a task-based study, which tried to gain new insights in this domain. The test was designed, prepared, carried out and analyzed in June/July 2003 with the german company relevantive AG as project lead and basysKom GbR as technical partner who took specific care for the KDE specific configuration aspects.
The paper discusses the intentions of a test with a significant number of "traditional Windows users" who got the chance to solve a number of standard office tasks on a KDE system as well as on a Windows XP system. The users behavior was filmed and analyzed afterwards.
We show the way we have configured the KDE desktop to meet the expected demands in a proper way, explain our intentions and rationales and evaluate the results of this study. The paper raises a number of questions that we consider worth observing for future development and
indicates the great challenges but especially opportunities that result from the migration of large installations from Windows to Linux systems in business environments. A general trend in this direction can be expected for the near future.
Web Reference: linux usability study
KStreamer in KDE-4.0Ronald Bultje<>
GStreamer is a full-featured media framework, currently included in the stable Gnome-2.2 desktop series. KStreamer is the nickname for the KDE/Qt bindings for GStreamer, currently used in KDE-applications like JuK. This paper will aim to give a demo/overview of several things that are possible with this powerful framework, how GStreamer is technically built up, and how KStreamer could become the basis of a new media framework in KDE-4.0.
Design PatternsMarc Mutz<>
Design pattern have greatly influenced the way object-oriented programmers talk about application designs. In this paper, we will present examples of design pattern usage in and around KDE. Starting with well-known Factory and Singleton patterns, we will also cover more recently formulated design patterns such as Null Object and less well-known, but oft-used patterns such as State/Strategy and Observer.
Target audience: Everyone from the "I know what a Factory is, but what the heck is a Null Object?" department. ;-)
Erich Gamma, Richard Helm, Ralph Johnson, John, Vlissides
"Design Patterns - Elements of Reusable Object-Oriented Software",
416 pages, Addison-Wesley, 1997
Intel's Hyper-Threading Technology for LinuxHeinz Bast<>
End of 2002, Intel® introduced Hyper-Threading Technology (HT) as a new hardware implementation for Simultaneous Multi-Threading (SMT) - two threads can share physical processor resources at the very same time. This is now available in all high-end desktop Pentium®-4 and all XEON® processors.
The talk will start by a brief update on Intel's desktop processor roadmap including the soon to be released Prescott CPU. Next the Hyper-Threading Technology will be presented in detail focusing on generic implications for developers interested in porting and tuning applications for the new features offered. For the Linux Operating System, the enhancements and optimizations in the scheduler already available in current releases and those planned for future releases (kernel 2.5.x/2.6) will be discussed. Additionally the Linux APIs to detect support for HT and to facilitate programming for HT will be introduced.
The second part of the talk will give an overview on Intel's tools to support developing for Linux focusing on the support for Hyper-Threading. This will include the Intel Linux compilers, the Vtune Performance Analyzer and the Intel Performance Libraries. Pennington<>
This talk will be about building infrastructure (including specifications and implementation) that's common to all desktops, toolkits, and applications for the X Window System. What progress has been made? What's in progress? What *should* be in progress? Why should we care - when does it matter to users? has been a center for work in this area.
To build common infrastructure, first we have to understand the various toolkits and applications that currently make up the open source desktop community. Thus, part of this talk will describe the state of the GNOME desktop infrastructure, including both the positives and the negatives. Where would GNOME developers be most interested in making improvements? What lessons can we learn from GNOME's experiences, about what to do and what not to do?
This talk will have some technical content, but is primarily a high-level overview.
D-BUSHavoc Pennington<>
D-BUS is a message system, a simple way for applications to talk to one another. D-BUS supplies both a secure system daemon (for events such as "new hardware device added" or "printer queue changed") and a per-login-session daemon (for IPC among user applications). The message bus daemon is built on top of a general one-to-one message passing framework, which can be used by any two apps to communicate directly without involving the daemon. D-BUS can even be used for secure IPC across an intranet or the Internet.
This talk will present the technical details of D-BUS as it currently stands. Hopefully, it will inspire discussion about the potential for using D-BUS in the KDE Project, and how to improve D-BUS with that goal in mind.