5 tricks and 4 and 1/2 tips for porting GNOME applications to the Maemo Platform

By: Eduardo Lima


The Maemo platform is the basis for developing applications for Nokia Internet Tablets (770 and N800 until now). These devices provide some basic applications pre-installed, such as PDF reader, Image Viewer, Media Player, Sketch and Notes tools, for instance. The big problem is we don't have access to the source code of these applications, so we usually need to wait for a major software upgrade for bug fixes or even new features to be implemented.

GNOME has a huge set of applications that can be perfectly used as alternative for the proprietary applications present in the Internet Tablets. For example, Evince can perfectly substitute the pre-installed PDF reader. It also has the advantage of providing many other file formats, such as PS, DVI, DJVU and Comic Books. In the case of the Media Player, we can use Rhythmbox for audio and Totem for video.

Porting GNOME applications to the Maemo platform can also bring new experiences in the use of these devices. We can have a Office Suite compatible with many file formats, including proprietary (Microsoft) ones, using Abiword for text processing and Gnumeric for spreadsheets. This way we avoid reinventing the wheel and always have the opportunity to have bug fixes and new features implemented quickly.

The talk will focus on showing pairs of the most common problems and solutions for porting GNOME applications to the Maemo platform with code examples.

A Modest E-Mail Client for Gnome and Maemo

By: Dirk-Jan Binnema


"Modest" is an e-mail client with both Gnome and Maemo frontends. It uses the Tinymail/Camel framework, and focuses on having a simple user interface and low memory consumption, while still delivering some advanced e-mail functionality.

In this presentation, I will go through the development, and the many interesting challenges dealing with e-mail on mobile devices. I will demonstrate what we've built. Finally, I will discuss some of our plans for the future, and invite the audience to tell us what they would like to see.

Target audience: end-users interested in technology and developers.

Accerciser: 15 minutes a day for better accessibility

By: Peter Parente


Accerciser is an interactive Python accessibility explorer for the GNOME desktop. It uses AT-SPI to inspect and control widgets, allowing you to check if an application is providing correct information to assistive technologies and automated test frameworks. Accerciser has a simple plug in framework which you can use to create custom views of accessibility information.

In this talk, I will demonstrate the use of Accerciser for debugging accessibility problems in GNOME desktop applications. I will first uncover accessibility problems by looking for "holes" in what Linux Screen Reader (LSR) announces to a user when he or she is interacting with an application. I will then use Accerciser to diagnose the cause of a problem in the application. I will present a number of techniques for finding the source of such bugs ranging from simply interpreting the information shown about accessible widgets, to watching for appropriate events from an accessible application or object, to using the IPython console and custom scripts.

This talk is intended for application developers hoping to improve the accessibility of their software. Diagnosing and resolving accessibility problems can lead to a better user experience for people with disabilities and improved support for automated GUI testing.


An E-mail framework for mobile devices

By: Philip Van Hoof


Tinymail is a library for developing mobile applications with E-mail functionality. The framework provides components that aid the developer with the user interface but of course also with the connectivity and the caching of messages.

Today it implements Push E-mail using IMAP idle and a few other mobile-targeted Lemonade improvements of the IMAP specification. Including condstore, binary, uid search and many more.

Tinymail aims to be good at synchronizing the locally available cache with the remote mailbox using as few bandwidth as possible. The idea behind this is that connectivity with a network isn't something that can be guaranteed nor is something that should be assumed when working with mobile applications. Yet will the tinymail framework also put an important focus on making sure that while-you-are-online functionality works well too. Examples are push e-mail functionality like acting on new messages, acting on expunges and on changed flags.

Tinymail is not about only IMAP. By the time the GUADEC conference will start I expect to have multiple Push E-mail implementations. Including a SyncML one.

Tinymail as said also implements and specifies certain ui components that makes it more easy for application software developers to leverage the framework. Its team aims to develop language bindings for all the typical higher programming languages. Python language bindings are, for example, available today.

The talk will be about, tinymail. Future past and present.

Beginners Guide to UI Design (Tutorial)

By: Máirín Duffy


A one-hour tutorial session on how to go about coming up with a usable UI design for an application, aimed primarily at developers. I would like to step participants through the design process I followed for Virt Manager (http://virt-manager.et.redhat.com/), a GUI for managing virtual machines. I will talk about:

  • how I first got involved with the project
  • the types of questions and research I did into the target audience, motivation behind the application, and the current usage of virtual machines in order to inform the design and prioritize features
  • the initial pencil sketches I did of the UI (of course I will show them) and other mockups
  • how to do quick UI mockups in gimp and inkscape
  • the pros/cons of selecting particular widgets for particular tasks
  • the design revision process (referring to the GNOME HIG as necessary as well as other GNOME developers on advice for improvements)
  • how to do quick paper prototype (or screenshot mockup) usability tests to answer specific design questions
  • walk through some of the iterations that we made to the UI design to include additional features such as a wizard to create new virtual machines and multiple host system management (upcoming feature, right now virt-manager only supports one host.)

Developers will walk away from this talk with sheets outlining the UI design process, with questions and tips for each step of the way that they can follow along with when working on their own UIs.

Two books I will reference include Interaction Design by Jennifer Tidwell (on weighing the pros/cons of selecting particular widgets for particular tasks) and Getting Real by the 37 signals team (http://gettingreal.37signals.com/). Some of the sketches and mockups that I'll make available are available right now on the Virt Manager website (http://virt-manager.et.redhat.com/mockups.html).

Block Party - Learning how to Develop for the OLPC Sugar Environment Through Fun and Games

By: John Palmieri


Block Party is an adaptation of the classic game Tetris for the Sugar Environment. It was written in python by one of the original Tetris developers, Vadim Gerasimov, and integrated in stages by John (J5) Palmieri to serve as a fun tutorial for developing Sugar activities. Beyond learning about the Sugar environment this talk will cover ground such as:

  • python
  • OO vs procedural programming
  • pygtk
  • the gtk mainloop
  • porting from gdk to the cairo drawing layer
  • networking applications (telepathy)
  • game programming

Bluetooth and GNOME

By: Bastien Nocera


Bluetooth is a wireless technology aimed at replacing cables for communication between electronic devices.

Linux has had a full-featured Bluetooth stack in the shape of BlueZ for some time now, but the desktop integration has not been as forthcoming as on other platforms.

Recent works in the backend make it possible to integrate Bluetooth better in GNOME and the Linux desktop in general.

Build Brigade: Continuous integration and QA for Gnome

By: Iago Toral


Having a server or a group of servers with different software and hardware architectures where all Gnome modules are compiled frequently provides the community with a lot of useful information. Developers would detect some problems in their modules automatically and soon, and advanced users would be able to compile Gnome from sources and check if they are the only ones having a given problem or it is a known issue. It would, in the end, increase the quality of the delivered software.

Because this has been proved to be an interesting issue for the Gnome community, a group called the Gnome Build-Brigade was born with the aim to provide such a system.

This talk is intended to introduce the group and its work to the Gnome community in the first place, paying special attention to the Gnome Buildbot, the continuous integration system developed for Gnome

Building a Modern Multi-User Desktop

By: William Jon McCann


Despite the conventional wisdom that Unix-based systems are eminently multi-user, the Free Software Desktop has been effectively single user capable for a number of years. During that time, traditional single-user systems like Apple OS X and Windows have developed and now tout superior multi-user capabilities. We will discuss some of the architectural problems in our platform and how we aim to develop a modern multi-user desktop.

Building plugins for GNOME's applications using Python

By: Germán Poó-Caamaño


In order to contribute to GNOME developing applications it is not required start from scratch which sometimes could be intimidating for newcomers. Also, looking specific parts of a big piece of code could intimidating to start with. While it is possible start using tools such as cscope, not everyone feels comfortable when is a beginner in a long live open source project.

The objective of this tutorial is to help to new potential GNOME's developers to get custom with the applications in GNOME Desktop that are user every day and show how easy and fun could be add them features or extend them getting results quickly.

For this tutorial I have chosen Nautilus and gEdit as applications to be extended. Nautilus, because the impact it has from day to day and because it is easy to mix them with small script shells, that normally everyone writes. And gEdit, because it allows to work with documents and it is possible to getting familiar with more complex widgets.

Suggested topics:

  • A 5 minutes crash course of PyGTK+
  • Overview of a plugin system
  • Initialization/Registration
  • How and when a plugin is called
  • Structure of Nautilus plugins
  • Overview of providers
  • Working with columns in the List View
  • Working with menus
  • Contextual menus
  • Background menus
  • Adding actions to the tool bar
  • Working with Property pages
  • Helpers
  • Integration with external programs/scripts
  • Structure of gEdit plugin
  • Starting with the integrated shell
  • Working with Menus/UI Manager
  • Working with documents
  • Working with the side bar
  • Defining options in a plugin
  • Integrating applications with plugins and DBUS.
  • Other applications (Gimp, gazpacho, etc.)

This tutorial only has sense if newcomers are expected to attend. People who want to start programming cool applications using GNOME and want to put their hands working and seeing results fast. Basically, this tutorial is beginner oriented.

According the time available for this tutorial it will have emphasis on Nautilus or Nautilus/gEdit/Other applications.

Co-maintaining cairo: cool community, cool code

By: Behdad Esfahbod and Carl Worth


Most talks are given by a single person, but our code isn't written that way, so we didn't want to present that way either. Cairo recently celebrated[*] 5 years since its first commit. It started with one programmer having fun and sharing his code in case others would find it useful. Now, more than 80 people have contributed code to cairo, (more than 60 in the last year alone). Presumably many more have had fun programming with it as it has become a core part of GNOME as well as several non-GNOME applications.

The accelerated growth of the community also corresponds with an acceleration in the capabilities of cairo itself. In the last year it has gotten much faster, and is producing better-quality output than ever before. We will describe our experiences as co-maintainers of the project during this period, sharing highlights of what has worked well within the community and the code, and what challenges we still face.

[*] Or will have celebrated by the time of GUADEC 2007.

Collaboration within GNOME (revisited)

By: Adam Janos Reviczky


Collaboration is one of the most important feature in the near future. This is about the status of collaboration in GNOME. What means collaboration

Right now, you can chat with peoples - through various protocols - using instant messengers. If you get a problem or want do something together you can already discuss it with the corresponding people. But with collaboration you can do more in less time. The ability of chatting remains still there, plus all participants see the same and can do it on the same thing. More there can be revisions to track the work of each ones. Applications that support collaboration (demonstration)

  • Gobby was one of the first collaborative capable editor in GNOME. Easy to use, good for developers to code together and for reviewing a code. Also good for nearly anything that can be done with a text-editor, like LaTeX for publishing or PHP for web designers. Support of colorized revision control, but also lacks of some features and has limitations.
  • Abiword with it's collaboration feature is the answer for WYSIWYG team work word processing. Beside multiple editing of documents it supports text formatting, inserting tables and most of abiword's feature set.
  • Inkscape with its pedro xmpp is the next rocking GNOME application in the line. A perfect example of collaboration that is not based on text input, but on drawing.

Collaboration in a different way

In multimedia applications we can have also collaboration features. Avahi (Tangerine) only shares sources between Ryhthmbox, Banshee or even VLC, but this can be extended to have real collaboration in multimedia applications too. Another example is gShrooms for listen to the same music through Gaim and Rhythmbox. Alternatives of application-based collaboration

A circumstantial solution for simple text editing is pastebin (+ instant messenger for chat). / This can be compared with Gobby. Google of course with it's web based products, mostly "Google Docs & Spreadsheets". / Compared to Abiword/Gnumeric. The future of collaboration

Easy integration with common GNOME applications through Jabber/XMPP (Telepathy). There are also some 'candidates' for supporting collaboration feature like Gedit/collab-plugin, (Gobby successor) Infinote and Jokosher with it's network instrument approach. Most of them is brought to you through the open Jabber/XMPP servers, so you have all it's advantages like SSL. If you see the possibilities of collaboration, than you can imagine what can be done with that.

Creating Alternative User Interfaces with LSR

By: Peter Parente


The Linux Screen Reader (LSR) project is an open source effort to develop an extensible assistive technology for the GNOME desktop environment. The goal of the project is to create a reusable development platform for building alternative and supplemental user interfaces in support of people with diverse disabilities.

The primary use of the LSR platform is to give people with visual impairments access to the GNOME desktop and its business applications (e.g. Firefox, OpenOffice, Eclipse) using speech, Braille, and screen magnification. The extensions packaged with the LSR core are intended to meet this end. However, LSR's rich support for extensions can be used for a variety of other purposes, such as:

  • Supporting novel input and output methods (e.g. mouse gestures as input, audio icons as output)
  • Creating interfaces for users with disabilities other than visual impairments (e.g. people with mobility impairments, people with cognitive impairments, children with autism)
  • Supplementing the graphical GNOME desktop (e.g. speaking events outside the active desktop workspace)

In this talk, I will demonstrate how to create a new user experience in LSR reusing some existing extensions and creating others from scratch. Some possibilities for the demonstration include 1) using web cam video as a no-touch input device, 2) peripheral audio announcements of syslog events for administrators, or 3) mouse input gestures as macros for applications.

See http://www.gnome.org/~parente/lsr/screencast/lsr-gsummit06.html for a brief version of what this talk will be about.

Creative Commons and the Open Content Library: Building Large Scale "Open" Communities around Multiple Media

By: Jon Phillips


The Open Content Library is understood multiple ways. It is a social and technical strategy for building large scale "Open Content" licensed communities around specific media. Secondly, it is a superset around existing projects such as the Open Clip Art Library (www.openclipart.org) for public domain 2D clip art images and the Open Font Library (www.openfontlibrary.org) for public domain fonts. The Open Content Library is now also a new project, www.opencontentlibrary.org, where these specific communities are loosely collected under one umbrella, in true Wikimedia-learned-fashion.

This presentation first looks at the current landscape of projects that exist with similar scope such as Wikipedia.org and Archive.org, and also contrasts differences with some sites such as ccMixter.org where the focus is on remix, rather than on growing the collection of content with further bite-sized samples, necessary for remix as is the case with all Open Content Library projects. This section also discusses why this type of library is necessary in the world in order to support Open Content that is either released into the Public Domain, uses a Creative Commons license, or another Open Content license. Specific emphasis is placed upon the complexity of searching the world's global media collections and licensing this content properly so that anyone may use media when desired.

Secondly, this presentation discusses the aforementioned three key ways to view the Open Content Library, as a strategy, as a superset of pre-existing real projects, and as an umbrella for these specific projects.

And finally, the presentation will hover on HOWTO develop more large scale "Open Content" communities using the learned strategy. The social and the technical approaches are intermingled in order to show how to properly channel contributor energy using a broad scope of means, from "low-tech" to "high-tech." One key point is discussing the Creative Commons project, ccHost, an Open Source web-based media sharing application, and how it enables current Open Content Library projects to thrive because of how ccHost empowers groups socially and helps to lower impediments ("barriers") to contribution.

Jon Phillips is an open source developer, artist and scholar with 12+ years of experience building communities and working within computing culture. He is currently developing the Open Source project the Open Clip Art Library, works for Creative Commons and teaches at the San Francisco Art Institute in the Design+Technology department.

NOTE on sponsorship: Since Creative Commons is a nonprofit, full or partial sponsorship of my presentation would be desired.

Clutter Foo

By: Matthew Allum


Clutter is an experimental toolkit for creating heavily styled and visually rich graphical user interfaces. Clutter uses gobject, glib, pango and OpenGL (and GL/ES) for rendering. The Clutter API is similar to that of GTK but more 'raw' in nature with a number of specific features for creating animations and other visual effects important in the applications intended for.

This talk aims to provide a basic overview of Clutter discussing the motivation and goals of its development, usage and feature examples and finally some demos and ideas for clutter applications.

Developing Distributions for Fun and Profit

By: Scott James Remnant


How we develop Ubuntu, collaborate with our upstreams like GNOME and the developer/user interaction differs between a distribution and its users and GNOME and its users.

Developing XUL Applications

By: Ian McKellar


Mozilla's XUL technology has matured over the past few years to become a compelling development platform. It has become increasingly well integrated with GNOME desktop technologies while becoming more widely used to build cross platform applications like Firefox, Thunderbird, Songbird and Democracy Player.

I will present an overview of how to develop XUL applications on GNOME. I will discuss the advantages and disadvantages of the XUL and Gtk+ toolkits and their supporting platforms. I will also show how to integrate existing GNOME technology such as GStreamer and DBus into a XUL application using the Songbird media player application as an example.

While C and Gtk+ are likely to remain the most popular platform for GNOME application development for the time being we are gaining an exciting array of tools for building our desktop. XUL is uniquely placed to enable rapid development of desktop applications, particularly those focused on the web. XUL applications can remain tightly integrated with GNOME while reading a wide audience of users on other platforms and developers who are familiar with JavaScript, XML and CSS.

Development Platform Radiographs

By: Quim Gil


GNOME is a development platform as well, as you have probably read. What does this exactly mean? What do we have, what do we miss? What is rocking, what is sucking? Is it useful for core GNOME developers, is it attractive for newcomers? How good is it compared to what our competitors are offering nowadays?

A non-developer will do a little research trying to find out, including some interviews to GNOME a non-GNOME developers. I plan to deliver the results in this session, plus some thoughts to move forward. I will be doing anyway this work for my job as maemo product manager, since we rely a lot on the competitiveness of what GNOME has to offer to developers. This will also bring the question of how projects and organizations around the GNOME project can contribute and team together to improve the common elements of this platform.

PS: Don't expect this to be the definitive report/strategy/competitive analysis about the GNOME development platform. In fact the plan is to come up with some radio graphs and a short presentation in order to open the discussion afterward.

Eggs, wine, and sugar: making your application friendly to Sabayon

By: Federico Mena-Quintero


The majority of GNOME users come from the "big deployments": Spain, India, Brazil, countries in the EU. The best way to increase the number of users of GNOME is to make it as friendly as possible to these big deployments.

The 2006 report on GNOME deployments ("World Domination as an Optimization Hack") indicated that the largest problem for these deployments is the lack of good tools to do large-scale administration of desktop software. This is the software that administrators would use to pre-configure desktops for their users, lock down configuration options, and customize the desktop for their site.

GNOME provides Sabayon, a young but promising tool to do this kind of configuration and lock down.

In this talk, we will examine the current status of Sabayon and the problems that remain to be solved. We will also discuss what kinds of things need to be done in application programs to make them friendly for large-scale deployment.

You should attend this talk if:

  • You are a system administrator interested in deploying GNOME
  • You are a GNOME hacker interested in making your application friendly to Sabayon and deployments.
  • You want to hang out with the tastiest GNOME project right now.

Elisa: Media-Center for masses

By: Philippe Normand


Enjoying, organizing, discovering new digital medias is becoming an increasingly important task for the modern couch potato and desktop user. Elisa is a rapidly maturing media-center application designed to integrate easy multimedia playback and management in your daily life.

Elisa is developed in Python, it heavily relies on the GStreamer multimedia framework and uses a switchable rendering/widget/animation engine called Pigment allowing Elisa to run on graphical hardware implementing OpenGL APIs and/or supporting DirectFB rendering. It's designed to be easy to extend using a plugins system. Packaging and deployment are managed by Python Eggs.

Elisa is funded by Fluendo, there are currently four developers and a designer working full-time on the project.

In this presentation Philippe Normand will provide a hands-on demonstration of Elisa. He will discuss some of the original design goals, possible integration with the GNOME desktop and problems encountered during development. Finally he will offer up ideas future development and a glimpse of upcoming features.

Evolution - Today & Tomorrow

By: Srinivasa Ragavan


Evolution in the last one year has gone through a very different phase than ever before. Even in the recent Evolution 2.10 release, not may new features were added and the focus remained with stability and performance improvements. I would be talking about the different steps that the Evolution team carried out in taking this goal forward.

Also the team is working on a road map for the next few releases having this goal set. I would talking about the Evolution road map in detail. Also I will be discussing some of the steps that we are taking to address the existing issues like patch review, etc.

The session would also focus on explaining the existing woes and how the road map is going to address that.

F-Spot: Wide Angle

By: Larry Ewing


F-Spot is a popular GNOME application designed to simplify the challenges presented by digital photography. After years of development, it's time to step back and take a broad view of where F-Spot needs to go. What does F-Spot do well? Where does it need to improve? What makes taking pictures fun and how can we make it more fun? Both GNOME and digital photography have changed since the project started, and we should take advantage of those changes. This talk will present an overview of unsolved challenges in interaction, technology, and community, then provide a road map for future development. Topics will include: meta data, searching, sharing, RAW formats, GeoTagging, color management and accelerometers.

F-Spot/GIMP Work flow for editing digital photos

By: Jakub Steiner


A tutorial-based talk targeted at users. Demo basic photo management and common editing techniques using GNOME, F-Spot, GIMP. From acquiring to sharing on the web.

Free Software for the Socially Excluded

By: Richard Rothwell


M6-IT are just about to roll out over 100 desktop computers, for free to socially excluded families in Nottingham - using a complete free software solution with a Gnome desktop.

Geodata standards, GeoClue project.

By: TuomasKuosmanen, HenriBergius and AndrewTurner


Emerging open-standards such as GeoRSS, KML, geo-uri, and Geo W3C all enable easy publishing and sharing of geographic information from many data sources. GeoClue aims to provide users with a application that can determine their position from a variety of location providers and find information that is local to them.

Examples include pulling in local news, weather, friends locations, and interesting locations to visit while traveling. You can also publish your location or travels to location sharing sites such as Plazes for finding nearby friends or contacts.

GeoClue project started in October 2006 Gnome Summit. The idea was and is to provide an easy way for many different applications to obtain information about geographical location.

We will demo GeoClue, some of the location providers, and additional applications that are being built on top of the GeoClue service.

Getting GNOME in your own language (GNOME Love day tutorial)

By: Sayamindu Dasgupta


GNOME is currently translated into xx languages. This half an hour tutorial will cover how to translate GNOME to your own language, and some of the lessons that we learned while doing Bengali localization of GNOME.

Topics to be covered include:

  • Getting support for a particular language into GNU/Linux (glibc issues, locales, etc)
  • Fonts and Rendering issues (overview of Pango)
  • Input issues (SCIM, GTK-IM, XKB, creating custom key maps)
  • Translations (Introduction to the GNOME Translation Project, concept of core-libary packages, desktop, fifth-toe, anatomy of a PO file, translation tools)
  • Case study and lessons learned: bn and bn_IN project.

People who are interested in contributing to the GNOME Translation Project, either by translating GNOME applications, or people who want their (currently unsupported) language to be supported in GNOME should attend this session.

Getting Started In Marketing

By: Quim Gil


Introductory session run in coordination with GNOME's marketing team. We will summarize the basics of our current strategy: audiences, messages, channels, objectives... And to put this theory into practice we will recommend some actions to anybody willing to promote GNOME.

The session is not a classic tutorial but targets the Warm Up weekend (unless you think it might be more suitable elsewhere).

PS: The actions might be 7 or more/less. I was just trying to find a catchy title. ;) Note that as for today the marketing team hasn't agreed anything at this level: this session would be a good excuse to (finally) have something formally accepted.

Gnome accessibility for blind people

By: Jan Buchal


Blind speaker will present usage of the Gnome desktop and applications such as Firefox 3.0 or OpenOffice.org with speech and braille output. Interoperability with other accessibility solutions, such as Speak-up, brltty or Speechd-el will also be explained. The speaker is the director of the non-profit organization Brailcom, which is in long term involved in development of Free Software for blind and visually impaired people.

GNOME Administrators' BoF

By: Sayamindu Dasgupta


The number of medium to large scale GNOME deployments worldwide is increasing each year, and this BoF aims to bring together the people who administer these deployments, and the developers from the GNOME community.

Topics that can be covered in the BoF include (BoFs are supposed to be informal, and hence this list is totally flexible):

  • Tools for administering large deployments
  • Lock down
  • Centralized configuration management/repositories (LDAP, APOC??)
  • GNOME on Thin Clients
  • Profile management
  • Stateless Linux and GNOME
  • Requirements from the SysAdmin/DesktopAdmin perspective

People who should attend this BoF include:

  • GNOME Deployment Administrators
  • People interested in deploying GNOME (either mass scale deployments or kiosk like locked down deployments)
  • Developers who work on deployments tools in GNOME
  • Developers who are interested in making their applications more deployment friendly.

Gnome Memory Use: Naming and Shaming the Culprits

By: Tomas Frydrych


The question of the GNOME memory use crops up regularly on p.go. Are we doing better or worse than desktop XYZ ? How much memory do we really use? Where does it go ? What can we do to make it better so that GNOME performs without hiccups on less than cutting edge hardware ?

The proposed talk will look in some detail at the patterns of memory consumption of GNOME Desktop in regular day-to-day use, identifying the major memory consumers and looking at possible ways of improving overall performance. In the process the talk will also demonstrate the use of the Exmap-Console suite of applications for analyzing system-wide and per-application memory use.

GStreamer - more than just playback

By: Zaheer Abbas Merali


Showcasing applications using GStreamer for uses other than playback, with high level details of how they use GStreamer to achieve their goals. Also the talk shows some wacky ideas that shows off GStreamer in a multitude of ways. The talk is to bring attention to the diversity of functionality (while still remaining conceptually simple) that GStreamer offers for app developers.

GTK+/GNOME - Best Practices

By: Sven Herzberg


This talk will be dedicated to people who consider themselves beginners in the area of GTK+/GNOME software development.

It will cover some issues that show how to make the user's experience a bit smoother when using an application.

The talk will be split into several "best practice" issues (one of them is the window geometry saving) and will try to give the audience an insight into the internals of GTK+ and as well some theoretical knowledge about how to implement things.

Example: Window Geometry Saving

  • Why you don't want to save the position (Xinerama, RandR 1.2, unplug-able screens, unreachable windows, etc.)
  • Why you shouldn't save into GConf (GConf might be located at a read-only medium, Administrators might have locked the whole tree down)
  • Why you shouldn't save the window size if the window is maximized (because the user wants to be really able to use the "restore" button of the window decoration)

Another topic I'd like to talk about is »How to implement lock down features in your application using GConf«. Other topics will be added when I have ideas and the necessary talking time to show them.

Gtk+ 3.0: "Why and why not would we want it?"

By: Fernando Herrera and Xan López


In this talk we will present some topics about the possibility of having a new Gtk+ version breaking ABI/API:

  • New features that could be implemented only breaking API/ABI
  • Benefits from the maintenance point of view
  • Cost of migrating from Gtk+ 2.x to 3.x

We expect to present these topics and then discuss them with the whole audience

GTK+ State of the Union

By: Kristian Rietveld


During this "State of the Union", we'll give you an update of the current state of GTK+ development with the latest news straight from the GTK+ maintainers.

After a rundown of the new features and enhancements in GTK+ 2.12, we'll have a brief look at the status of Project Ridley. And as a logical ordering would imply, the talk will be concluded with a short look into the future, possibly with the first ideas and themes for GTK+ 3.x.

We are not able to provide a fully detailed description of the talk at this point, as we want to provide the developers with the latest GTK+ news during the talk.

GVFS: The making of a virtual file system

By: Alexander Larsson


I've recently been working on gvfs, a replacement for gnome-vfs. This talk will give and overview of gvfs, its design and development, and how it is better than gnome-vfs. I will also give a mini-tutorial on how to use the API, and how to convert applications using gnome-vfs into using gvfs.

happier applets

By: Ryan Lortie


Two years ago at GUADEC, Davyd Madeley presented a talk, "Applets Revisited". Last year, as part of Google's Summer of Code, I implemented many of the ideas that Davyd presented in his talk. As a result of this, there is now a new library -- libgnome-applet.

This new library offers many improvements over the old libpanel-applet. The most fundamental improvement is that applets can add and remove themselves from the panel automatically (without requiring user intervention). There is a new vastly simplified API for applets that only want to display an icon and/or a label. Transparency hacks performed in the old applet library have also been removed (and replaced with real alpha compositing). The new API also completely hides the underlying IPC and configuration system mechanisms (removing Bonobo and GConf code from applets).

There are many more advantages to using the new API as compared to the old one.

This talk will give an overview of how to write applets for the new API. It will explain how to use the new applet API as a drop-in replacement for GtkStatusIcon. It will also explain how to create panel applets in Python.

Hiker: An Application Framework for Mobile Linux Devices

By: David Schlesinger


Smart phones and mobile devices have limited memory, tight storage, small screens and slow CPUs, as well as a very different usage model than PC based systems. ACCESS has released to open source a number of useful components as the "Hiker" project, which address key needs of mobile applications in a number of areas:

The Application Manager and Bundle Manager handle the application life cycle: installation, task launching, transitioning to different tasks, exiting a task, and removing an application. The Application Manager includes a plug-in architecture of launch pads, supporting applications from any variety of execution contexts. The Notification Manager, Attention Manager, and Alarm Manager allow tasks to notify one another, or the user of the device, of event- or time-based information; target tasks can receive notifications whether or not they're actually running when the notification is sent. The Exchange Manager associates structured data (e.g. a contact or an audio file) with "verbs" than operate on that data (e.g. "call a contact", "play an audio file") allowing all tasks access to different kinds of content. Global Settings implements a tree-structured, access-protected registry for system information. It uses the open source component libsqlfs, which creates a virtual file system within an SQLite database. The Security Policy Manager and Hiker Security Module use certificates and code-signing to provide security via policy. APIs can be "sand-boxed" into "access tiers", allowing an open development environment while still protecting sensitive resources from unauthorized code.

This presentation will examine the Hiker framework in detail and describe its use in a Linux-based phone platform.

How to build GNOME applications using Python (GNOME Love Day Tutorial)

By: Sayamindu Dasgupta


Python is fast becoming one of the primary languages of choice for upcoming GNOME applications. Developers are increasingly beginning to love the simplicity and ease of use of Python. The purpose of this tutorial is to introduce Python and the GNOME/GTK+ bindings for Python to people who want to start contributing to GNOME. This one hour tutorial session would cover:

  • Basic introduction to the Python language
  • PyGTK bindings (including walk-through of a typical hello-world example)
  • PyGNOME bindings (basic overview of all the libraries, with walk-through of examples based on GConf and GNOME-VFS)
  • Introduction to Glade and libglade (python bindings)
  • Pointers to further resources (online tutorials, books, mailing lists, etc)

People who should attend this session:

  • Python developers (and non developers) who are new to GNOME and want to contribute code.
  • Users who want to contribute to GNOME as a hacker, but don't know how to proceed.

Integrated communication framework for GNOME - elements of Telepathy

By: Naba Kumar


Internet-based communication has now become as common as web browsing, and has grown beyond pure e-mailing or instant messaging. The variety of communication services and applications available today call for an integrated communication framework. Because of the growing popularity of GNOME Desktop, it is thus natural to think of such a framework for it.

Mission Control, along with rest of the Telepathy framework components, constitutes a complete communication platform. Telepathy framework provides unified ways to access communication protocols, such as XMPP, SIP, IRC and so on. Mission Control is a Telepathy component that decentralizes communication based on Telepathy framework and presents means for applications to tap into user's communication channels (IM/voip/presence etc.). In this talk we will see what this integration could bring to the application developers, along with several example scenarios.

By using Mission Control within the Telepathy Framework we enable GNOME Desktop users to utilize just about any communication service, using a single unified framework. See http://mission-control.sourceforge.net and http://telepathy.freedesktop.org

The talk provides following views:

1. Application developer (eg. integrated presence, online gaming, collaborative document editing, music sharing)

2. Protocol developer (eg. Adding ICQ support to the platform)

3. Core developer (eg. providing alternative way of notifications, network 'smart' connectivity etc.)

  • Extending Mission Control
  • Adding custom channel filtering

Introduction to the GNOME Foundation

By: Quim Gil


Wondering what is the GNOME Foundation about? Thinking if this is something for you? Considering joining but not sure why? This is your opportunity to get the principles and the facts in a live session run by [some board members to be defined].

Improving the GNOME Foundation BoF

By: Quim Gil


Time to share thoughts and action points in order to improve the GNOME Foundation. The board invites you to start adding topics here, so we can get easier into details and decisions during the BoF.

Large scale gnome deployment at schools in Andalusia (Lessons learned and new challenges)

By: Antonio José Sáenz Albanés


In Andalusia (Spain), since 2003, we are deploying at more than 1,100 schools more than 150,000 gnome desktops for everyday use. We have got one of the biggest educational networks based on free software. From the CGA (Advanced Management Center) we deploy, test, manage issues, manage the network, ... We also customize the Guadalinex distribution (http://www.guadalinex.org/modules/news/) based on Ubuntu Linux (http://www.ubuntu.com/) to meet the special unique and BIG requirements of this network.

Last year in GUADEC 2006 we presented the origins, goals, and challenges of the project. We also explained our objectives for this year (2006-2007 deployment)

please see:

One of our objectives this year was process enhancement thru a pragmatic and open-sourced approach to ITIL (http://en.wikipedia.org/wiki/ITIL) And we want to share our experience on this issue.

We also have developed new tools and enhanced the old ones. So we want to explain (from a high altitude perspective) them.

And finally like last year we want to share our knowledge on:

  • Hardware issues
  • Thin clients vs. big desktops
  • Roles in the deployment
  • Gnome desktop / Guadalinex customization
  • Gnome desktop large scale management
  • Bullet proof desktop for children
  • Network of desktops management
  • Testing
  • Linux/Gnome integration from the point of view of the users (children and teachers)
  • Helper applications
  • Needs
  • ...

We are open to feedback from the community, what are the aspects of the project you want to be included in the talk show once you have read last year presentation (http://antoniojose.saenz.googlepages.com/guadec-2006)

e-mail contact: AntonioJose.Saenz (at) isotrol.com

C.G.A. Project Manager (http://cga.org.es) Chief Technology Officer at Isotrol (http://www.isotrol.com)

Latest evolutions in Hildon Desktop

By: Lucas Rocha


Hildon Desktop (formerly called maemo-af-desktop) is the main UI component of Maemo Platform. It has been completely rewritten for the future releases of Maemo. Our main goals are flexibility, scalability, maintainability and developer-friendliness.

Hildon Desktop features a new UI framework which provides flexible and scalable ways to implement different kinds of user interfaces; a new plugin system with support for GTypeModule-based and Python plugins, more compliance with FreeDesktop.org standards, and much more.

In this talk, I will give an overview of the Hildon Desktop architecture and design, the new plugin system, some hacking possibilities, and all other cool stuff that is coming in the future releases of Maemo UI.

By: James Vasile

Description: Legal issues are among the most important concerns facing free software developers. This presentation will focus on the most important of these issues, and it will outline the pro-bono services that the Software Freedom Law Center can provide to help GNOME developers make informed decisions.

If desired, up to half of the scheduled time of the talk can be a Q&A session. The description of this talk is flexible and open to suggestion.

From our perspective, the best days for the talk would be the 15th, 16th, 20th, or 21st.

Please use Jim Garrison (garrison@softwarefreedom.org) as the contact for this presentation. We would certainly appreciate sponsorship for our travel/lodging expenses, but that may be flexible.

Let's put the N back into GNOME ... with Avahi

By: Trent Lloyd


[ABOUT THE TALK] The N you say? It was originally proposed GNOME could stand for "GNU Network Object Model Environment", the N was for NETWORKING! GNOME no longer stands for "GNU Network Object Model Environment" but I think we can bring the N for Network back! The GNOME project already aspires to zero configuration principles at an application level, but this can be extended onto the network using service discovery with the Avahi[1] project, which is currently not being fully exploited on today's GNOME desktop.

The Avahi[1] project allows application developers to provide an easy-to-use zero configuration user experience, through service discovery, which is currently not being fully exploited in the GNOME desktop. With default support of Avahi ubiquitous (FC5, RHEL5, Ubuntu Feisty 7.10, Debian Etch, etc...), it's almost guaranteed your user's can exploit this functionality on their Desktop of choice.

Utilizing the mDNS[2]/DNS-SD[3] protocol, an adoption of other DNS standards - pioneered by Apple[4], Avahi allows desktop applications to discover other applications and services available on the network, so things can simply be selected from a GUI, rather than entering cumbersome IP/Port combinations.

Some applications, notably Nautilus(GNOME-VFS), Ekiga and Rhythmbox provide basic support, but could be improved and many applications simply have no support at all - yet! Currently this ease of configuration is much enjoyed in the Apple MacOS X world, and there is no excuse for GNOME-based desktops to fall behind, in addition as Avahi makes use of the same protocol as MacOS X does, users can enjoy cross-platform application integration, already seen with compatibility between Rhythmbox and iTunes.

This talk will walk a developer through integrating Avahi into their application, both in specific cases, and very easily using Avahi's simple Network Service Selector dialog('avahi-ui'), which has made integrating Avahi into GNOME applications as easy and choosing a file from the file selector, which is very useful in cases where entering a manual host/port may still be useful, such as configuring a POP, IMAP or SMTP server.

Examples will be walked through in both C and Python and developers should expect to walk away with the ability to implement Avahi in their applications.

For more information see the project web-site at [1]http://www.avahi.org/

[ABOUT THE AUTHOR] Trent 'Lathiat' Lloyd[5] is a free software enthusiast and developer, co-author of the Avahi[1] project with Lennart Poettering, and has made contributions to other projects including Evolution[6] and Ubuntu[7]. Currently working as a Network Administrator for 45RU[8], preferring to code free software projects as a hobby and not an occupation. Previously rocking Avahi into conferences such as GNOME.conf.au 2005[9], Linux.conf.au 2006[10] and GNOME.conf.au 2007[11], could GUADEC be next?


libgnomedb: Database UI Widgets

By: Murray Cumming


I will introduce libgda and libgnomedb 3.0, with a brief overview of their key concepts. You will see how to build a user interface with libgnomedb's data-bound widgets, to show data from a database, accept input, and write the data back again when appropriate.

Low fat, a possible path towards GNOME 3.0/4.0?

By: Mirco Müller


low fat, while still being in its very early stages of design and development, could offer a possible path to a far more user-friendly and clutter-free desktop-system. The "UI-less" approach of low fat coupled with search-engines like beagle/tracker/etc would introduce a seamless and natural high-level view of user documents (images, videos, audio, documents). Furthermore it would map very well to screen-only setups (just touchscreen, no mouse, no keyboard) and even allow a normal desktop UI to be multi-user ready (in terms of multiple users using a single but large screen, e.g. embedded in a table-top setup). In addition to that it would eliminate the notion of document-icons and document-viewing-applications, thus making the experience of data far more immediate than it is possible right now. low fat is OpenSource and licensed under the GPL.

Lightning Talks

A serious talk about Giggle

By: Carlos Garnacho Parro


Giggle is a git repositories manager, aimed to be powerful, good looking and integrated in the desktop. This lightning talk will have a brief look into its possibilities and how it can help developers to visualize and manage their source code repositories.

bzr-gtk - Revision Control Made Easy

By: Szilveszter Farkas


What is Bazaar? It's an easy to use distributed Version Control System with a vibrant community. Development was started in March 2005 and is funded by Canonical Ltd. Confirmed to work on 3 platforms: Linux, MacOS X, and Windows (entirely written in Python).

What is GTK? A cross-platform graphical user interface library used by thousands of projects around the world. Programmable through various languages (C, C++, Python, Perl, Java, etc).

How do they come together? There are users who don't like command line and prefer graphical user interfaces (non-geek alert). With the support of the integrated environment, you don't even have to remember all the commands: just point and click the right menu item.

User-perspective. Most of the core bzr commands have a graphical equivalent (proceeded by a 'g').

Developer-perspective. Bazaar can be extended easily through plugins (bzr-gtk is a plugin itself). As of the writing of this abstract, most of our interfaces are generated by pure Python code (some of them are still Glade-designed, but we try to reduce this).

Future plans. Everyone knows well that the development of a software never finishes. We don't stop improving our application thanks to our users' feedback.

Contributors. The maintainers are Jelmer Vernooij (Samba developer) and Szilveszter Farkas (Google Summer of Code 2006 participant). Original developers include Aaron Bentley, Scott James Remnant, and many others. Other contributors who helped with patches: Vincent Ladeuil and Alexander Belchenko.

d_store; a different database for rich applications

By: Onne Gorter


d_store is something I have been working on, and love to show it. It is not per-se gnome technology but could be used, there is a gtk tree model implemented which makes the stores available for combo boxes or tree views immediately. The format of lightning talk is good, but I would love to do a tutorial or a real talk if wished.

description: d_store is dynamic database engine that works almost like a spreadsheet, and you drive it using sets. Designed for data rich applications, like iTunes, address books or others. It stores items efficiently and everything is indexed. Good in tags, searching, hierarchies or anything else you can define on your data.

The api is totally c, which is also very promising, d_store encourages to re-use intermediate results. It is however limited to storing as much as you can in memory. So it is not a replacement for SQL alike databases. But 20.000 rows should not be a problem currently, and the aim is around 1.000.000 rows, depending on how it works out.

It is early beta stage software, pretty stable, but no native on disk file format. (CVS saving/loading fully supported though, and is pretty fast.)


Gstreamer as an alternative to OpenOffice

By: Greg Franklin


I will present a showcase of how the Gstreamer framework has been used by Warwick Student Cinema to develop a bespoke application specific to our needs. I will highlight why we chose to use Gstreamer, what benefits it provided and what difficulties we came across developing with it.

Motivation Warwick Student Cinema recently started using a data projector to display slide advertising before films. We initially chose OpenOffice for displaying the slides but kept running into limitations with its ability to integrate with the rest of our systems.

Gstreamer to the rescue The Gstreamer framework allowed us to develop an application quickly and easily with a minimum of application development experience. The application does a number of things that we were struggling to do with OpenOffice: 1. Enable people to add new slides without having to edit a presentation. They can just upload the new slide and add it to a play list. 2. The decode bin plugin to auto detect file types. We can now play almost any file type from png to flash and avi. 3. We could make use of virtually any control interface, including keyboard, RS232 and website to perform actions like fading out the slide immediately or displaying a specific slide.

Unintended Benefits Once we started looking at Gstreamer, we realized that we could use it for a number of additional functions. We play background music from a computer and realized we could use Gstreamer to do this. Not only that, but we could automatically fade out the music and switch to a different source when playing a slide that had audio.

Challenges We have run into a number or hurdles in development of the program.

  • We had to implement the gst-controller facility into some of the plugins.
  • We had to write additional functions into the xvimagesink plugin to allow us to do hardware accelerated transitions.
  • We also had to rewrite the swfdec plugin to support the new version of the swfdec library.

The Future Although we still have many of these features still to finish or implement, the Gstreamer framework is already allowing us to do things that would never have been possible with OpenOffice.

Hildon Desktop (Maemo UI) running on a Linux-PC

By: Karoliina Salminen

Description: Hildon Desktop running on desktop

A lightning talk about running the Maemo UI as your desktop. Planning to show a laptop running the Hildon Desktop.

Hildon Desktop is the main UI component of the Maemo UI. It consists of two panels and the Home area. Each panel can house plugins and basically function like on an ordinary desktop environment except for that this user interface was designed for touch screen use on mind and was originally developed to Nokia 770 Internet tablet. The new Hildon Desktop that will also run on the next generation Internet tablets, will be also runnable on desktop Linux and the talk is about to showcase with a laptop how it runs on Ubuntu Linux.

Hipo, iPod Management Tool

By: Pedro Villavicencio


Hipo is an application that allows you to manage the data of your Apple iPod, Hipo is written in C# using Mono and GTK#. In this lightning talk i want to demo the application and show to the developers and users the current features and our future plans for it.


hipo website

By: Scott Reeves


This talk covers enhancements made to the alacarte menu editor to better support the needs of system administrators. Currently alacarte's changes are not system wide, changes are stored local to the user. Extending this to directly edit the system files introduces other problems such as system updates erasing the custom changes. An extended version of alacarte allows per user or system wide mode editing, editing of any menu file and changes appear in the generated system menus but system updates do not overwrite the changes. Also only the changes are stored in a standalone system directory making it easy to roll out to multiple systems. The code is in a branch of alacarte and is being piloted in SLES10 SP1.

S-Flux: hiding applications to improve usability

By: Christian Barbato


S-Flux is a project aimed to hide the applications to users letting them concentrate just on the operations they'd like to perform on theirs documents (files). This is achieved by describing the user environment using semantic web technologies (RDF/OWL). Using this information S-Flux will be able to generate a dynamic and consistent GUI for the operations that can be applicable to the documents selected by the user. S-Flux is targeted to "first time" computer user and the main benefit of using it in a *ix environment is that the user will be able to use all (the configured) CLI tools using an automatically, on-demand, generated GUI interface.

The talk is aimed to let developers know about the project, to have some feedback about the integration with GNOME and, of course :-) , to involve some new developers.

The project homepage is: http://sflux.sourceforge.net The project blog is: http://sflux.blogspot.com

Soylent: Gnome is made of People!

By: Travis Reitter


Our beloved desktop gives us a number of ways to contact our friends, family members, co-workers, and flat-out strangers. However, the procedures for emailing and instant-messaging someone are completely different and expose a lot of unnecessary graphical interfaces. When you want to start an engaging chat with an old friend, the last thing you probably care about is which specific IM service they are connected to.

Soylent is an application that pulls together information for your contacts, to make communication people-centric. It uses Evolution Data Server to centralize your contacts' information and will incorporate Telepathy for messaging, VoIP, and presence services, Ekiga for audio and video phone calls, and so on. After Soylent matures, its core functionality will be split into an independent library for a desktop-wide people-flavored Gnome!

This talk will briefly explain the motivation for Soylent, its goals, describe and demo some of its features, and touch on future plans and ideas on integrating libsoylent into existing applications.

Soylent is in active development. Some of the features features listed above are not yet complete, but most should be before GUADEC.

References: Gnome Live Wiki Entry for Soylent Near-term Mockup

X Composite on Internet tablets: beyond the bling bling

By: Johan Bilien


The X Composite extension brings a huge potential to change the way we see and conceive our user interfaces. But so far it's been mostly about adding a bit of bling bling.

On Internet Tablets and other "smaller" devices, the classic window metaphor is quite suboptimal. We have experimented with using X Composite to present the user with a more adapted interface while still being able to run window-based applications. We present this experiment and a few results, in terms of performance and usability of the extension.

Maemo and gtk+: Past, present & future

By: Tommi Komulainen


Maemo is now two years old. During that two years we've been working hard on moving from the obsolete, and heavily customized, gtk+ 2.6 to more recent versions. This is a brief story of the past, the present, and the future of the Maemo widgets toolkit.

We'll have a brief look at some of the decisions made in the past, what was the reasoning at the time, what were the consequences and how dealing with those issues played a role in pushing recent gtk+ development.

We're now moving from playing catchup to looking beyond what the toolkit offers today. We'll share our ideas about where we want to take the toolkit in the future, what challenges are we facing, and how do we see efforts like gtk+ 3.0 and bling on the desktop.

Maemo UI: getting your application ready for the mobile desktop

By: Michael Dominic K.


Maemo interface used on the Nokia 770 and n800 tablets is based on the existing GNOME toolkit elements. Even though the same API can be used to build the applications, a different set of guidelines and widgets needs to be applied.

In this tutorial I'll give a quick overview of the main UI concepts of the maemo platform and focus on the challenging areas of the rich & robust mobile UI development. Typical application models/cases will be presented with practical solutions. Following subjects will be covered:

  • Limiting the resource usage by controlling what the user sees
  • Simple tricks for making the applications feel responsive
  • Making the interface usable 'on the go' by enabling the finger usage
  • Gtk widgets vs Hildon custom widgets
  • Custom theming
  • Common pitfalls shown on the examples of the existing community-contributed applications
  • Key differences and similarities between maemo and the GNOME desktop UI

Managed D-Bus

By: Alp Toker


Used in over a dozen Gtk+/GNOME applications and with support for several languages including C#, Python and Java, managed D-Bus aims to be a compelling alternative to libdbus for desktop IPC.

We will first explore why re-implementation is sometimes the best option, leading in this case to a much smaller, more manageable code base. Why clean room design? What were the pitfalls with the previous two libdbus CLR bindings and how did they influence the design of the new library?

A brief overview of the wire protocol and its recursive type system will be given to illustrate the tasks dealt with by the core of the library, and show how easy it is to start talking native D-Bus.

We will then look at the object mapping features to demonstrate dynamic compilation of optimized marshalers at runtime and support for CLR generics (templates).

At this stage it becomes clear how managed D-Bus can share the same high level API mapping code with the very core of the protocol library, essentially bootstrapping itself at runtime -- a unique opportunity provided by integrating the "binding" with the protocol implementation.

We can then take a brief look at the managed D-Bus protocol extensions and how they were received by the dbus-java and python-dbus communities, and see how GLib main loop integration allows single-threaded concurrent communication with multiple D-Bus connections.

The second half of the talk will provide hands-on demonstrations.

Two quick tutorials:

  • Converting an existing C# GNOME application to expose core functionality over D-Bus
  • Dynamically consuming D-Bus APIs with IronPython via D-Bus introspection

Case study:

  • Examining Banshee's extensive D-Bus use: Consuming HAL, NetworkManager, Notifications, Helix player APIs and exporting its own easy-to-use remote control interface. Is Banshee part of an emerging generation of highly-interconnected desktop components?

The talk will finish off with consideration of the future of desktop IPC in GNOME, distributed network applications and managed D-Bus as part of upcoming mobile Linux/embedded platforms.

Managing bugs and crashes in GNOME

By: Fernando Herrera


Our mapping of one crash = one bug worked fine during GNOME 1.x and most of GNOME 2.x. However with large deployments and new easy-to-use bug-buddy this doesn't scale anymore. That is why during GNOME 2.19 we are going to introduce the "debug server" system.

Let's discuss during this workshop how can we improve things:

  • User experience (e.g: "Your problem has been fixed in the latest version of software, please click here to upgrade")
  • Developers experience (e.g: Nice tools to view crashes)
  • Bug triaging force

Bug squad members, developers and distributions interested on improving user experience, as well as all GNOME users interested are welcome!

Mono Development

By: Szilveszter Farkas


This one hour tutorial would introduce the the basics of cross-platform development with the Mono .NET Framework to the audience.

Topics covered in the tutorial:

  • Quick introduction into Mono and .NET (basic knowledge expected)
  • Cross-platform UI library: Gtk#
  • Introducing full-featured IDE: MonoDevelop

  • Designing UIs with Stetic/Glade

Quick examples will be shown at each stage (Hello World-like applications). If time permits, I'd like to show the possibilities of the Mono framework (short introduction of F-Spot and Tomboy).

Target audience:

  • C# (.NET/Mono) developers who want to contribute to GNOME
  • Users/enthusiasts who still don't know how to contribute to GNOME

The speaker has a decent background in GTK programming, but only recently got influenced by Mono and its possibilities, so he faced the issues of a rookie GTK# hacker.

Multimedia Profile Management in GNOME

By: Aaron Bockover


Currently there is no suitable infrastructure and easy to use user interface that allows multimedia applications to present context-configurable encoding profiles in GNOME. This talk will discuss recent efforts to bring such a user-friendly-yet-powerful multimedia profile management system into GNOME. Such a system allows for example a CD-ripping application like Sound Juicer or Banshee, or an audio production application like Jokosher to present encoder profiles (Ogg Vorbis, FLAC, MP3, etc.) with easy to configure options to the user so they can make simple and informed decisions over the content to be mastered.

The talk will discuss and demo efforts already underway for bringing such a system into GNOME, which will be available for any application to use. An early, yet working version is already available in Banshee and is on its way to the rest of the GNOME platform. The talk will also serve as a forum for discussing what further options are needed from such a system. Currently we are at a sad disadvantage in GNOME regarding multimedia profiles - each application is left to implement their desired functionality in varying ways at varying levels of complexity, or use the existing outdated, confusing, and under-powered GNOME audio profiles support in GNOME media.

For more information on efforts already on the way and for more context for this talk, I have an early blog post about the first concept iteration of the system in Banshee:


Nemiver, toward debugging for the masses

By: Dodji Seketeli


Nemiver, a graphical symbolic debugger for GNOME.

Nemiver is a recent effort to write a standalone graphical debugger that integrates well in the GNOME environment. It currently features a GDB based backend to debug C/C++ applications.

This talk presents Nemiver's current features, exposes the rationale of its technical architecture, shows the challenges currently faced, and opens discussions on the future of the project.

Topics like nemiver's extension mechanism, backend abstraction, communication with GDB and unit testing strategy will be discussed.

New GNOME Control Center developments

By: Rodrigo Moya


This will be a presentation of the new features that are planned for gnome-control-center 2.20 and beyond, including:

  • Control center applets reorganization
  • Performance and maintainability fixes in gnome-settings-daemon
  • Other new features

It is intended also to be used as a discussion forum, so that attendees can express their feelings about the changes and propose other changes.

Nokia's consumer perspective for the Internet Tablet UI

By: Kalle Saarinen


Nokia is using Gnome based components to create Hildon User Interface Style for Internet Tablet product family and Maemo.

This presentation explains the rationalities and targets behind the design. Who are we designing for? What are the key topics we should concentrate on? What we mean by task oriented design? How Nokia attempts to create great user experience? How Nokia sees the future of Hildon User Interface?

Kalle Saarinen is Senior Design Manager at Nokia's Open Source Software Operations. He is also the chief designer for the Hildon User Interface Design.

Opening GTK to Java programmers: the past, present and future of the java-gnome bindings project

By: Andrew Cowie


java-gnome is the project to provide a set of Java bindings to allow GNOME and GTK+ applications to be written in Java.

You might think this goes without saying, but the target audience for our project are people who are Java programmers who happen to be using GNOME on Linux or Solaris and who just might like to write an application and want it to look good and therefore want to write it in their native environment - GTK. Unfortunately, GTK itself is hard! The GTK APIs themselves are rich and powerful but with that richness comes complexity and detail that needs to be mastered. In its native C, GTK programs are very nearly impenetrable, certainly exceedingly verbose, and brutally difficult to debug.

All these factors are areas where Java in general and java-gnome in particular are a great improvement. In particular, we've already seen that the combination of a naturally object-oriented language like Java along with the code completion features of a rich IDE like Eclipse make for a really excellent development experience.

Unusually for an Free Software project, java-gnome has been through five teams of maintainers over the nine years since it was started. This is remarkable. Yet longevity does not automatically define success. Over time, the code has become unwieldy, coverage is spotty, and the mapping of the underlying libraries to the API that was published was inconsistent. Worst of all the whole mess was entirely manually crafted. (And people used it? Yikes! No wonder it was abandoned!)

So, a new java-gnome team, lead by Andrew Cowie, has embarked on a complete re-engineering of the bindings. Along the way we've had to figure out the answers to some pretty fundamental questions. Like who are we doing this for (and who are we not doing it for)? What do we want it to feel like? How can we invest effort now so that the maintenance effort required in the future is marginal? And most importantly, should we bother?

The existing pool of people with Java expertise is enormous and is a large audience whom free software have largely ignored over the years. More than anything, we are working to ensure we give these people the power to write rich desktop programs and clients, and in the process bring a whole new crowd of people into the amazing world that is GNOME and Software Libre. And that is worth doing.

Why will this talk be of interest? No matter what project we work on, we all want our work to be valued, and to be used! Yet the magic formula for success in an open source project remains obscure. So in this presentation we will talk about the challenges we have faced, both technical (engineering & design) and social (bringing diverse collaborators together) and how we believe we have solved them.

Without boring people to tears, this will nevertheless be a consummately technical talk. We will delve into some of the hard issues that arise when trying to do binding of a C library from Java. We will talk about the complexity of doing handling memory allocation in an environment where one side is a managed runtime and the other is doing simplistic reference counts. And we will discuss best practices in API design we've gleaned as a result of input from experts across the Open Source spectrum both within GNOME and outside. And we'll cover the most rebellious design constraint of all: trying to make sure that our work will mesh with other projects in the GNOME language binding family. After all, we've all got the burden of trying to keep up with GTK and the other libraries, and the less re-inventing-the-wheel we each do, the better.

OpenMoko -- A Free Software Stack for Mobile Phones based on GNOME technologies

By: Mickey Lauer


This talk introduces the OpenMoko mobile phone platform and the first hardware platform device, the FIC Neo1973. It lays out the reasons that lead us to base our free software stack on GNOME technologies and shows the current state of affairs. It briefly explains the individual OpenMoko components and their usage. The talk concludes with a summary of what we found good and what we found less good and our road map for the future.

Organizing GNOME events

By: Chema Casanova Crespo


Lately the number of events related to GNOME is increasing. The people who get involved in this organization management find a lot of problems that an experienced person knows possible solutions. This BoF will look for sharing experiences among people involved in events organization and try to help people interested in organizing GNOME events.

This talk should be considered as a workshop were the people who organized or participated at GNOME related conferences, workshop, session o talks participate giving solutions and sharing problems that organizers use to have.

We will focus on discussing the objectives of the workshops/conferences/events (promoting gnome, technical discussion, involving new hackers in GNOME). Another subject will involve an analysis of different free software conference management systems (from a Wiki to a complete system as Indico).

Another topic will be how important is the marketing for Workshops, the difficulties of getting support and how to find sponsors. We will also talk about economic related issues, how to organize the volunteers, accommodation, meals, transportation, website, coordination, medias etc...

If this BoF is accepted i will ask the participation to different organizers of events like GUADEC and others related to GNOME, it would be nice that the BoF will be after GUADEC Core so that people involved in GUADEC organization could share its experience this year.

The final objective of this BoF will lead to give support to people interested in organizing events.

'Pain for Pleasure: designing the next iteration of the GNOME configuration system'

By: Emmanuele Bassi


GConf is currently the configuration system for the GNOME Desktop. It has faithfully served us for more than seven years, storing and notifying the changes in the preferences of every GNOME application. Unfortunately, GConf was never fully finished: since its very beginning, the same feature list has been floating around and is, as of today, still unimplemented. It also brings along the heavy dependency on CORBA and liborbit, and it prevents its usage in the lower positions of the platform libraries stack or on embedded platforms. Every attempt at switching to another configuration system must be carefully planned to be fully backward compatible, to avoid even the slightest disruption of the current installation base.

This workshop aims to present a possible new iteration for the architecture of the configuration system, starting from the overall design down to the API, allowing developers to share their views and ideas in order to:

1. move GConf below GTK+ in the platform stack

2. implement the missing features

3. clean up GConf's design and API

and hopefully agree on a design to be implemented in the following development cycle.

PatchSquad BoF

By: Lucas Rocha


The idea of having a patch reviewing team (aka PatchSquad) has been flowing around for a while. PatchSquad will bring many benefits to GNOME for:

  • volunteers, it's one of the best ways to learn the project code base;
  • maintainers, it lightens their load by pointing out potential problems in submitted patches so that they don't have to
  • patch submitter, potential problems are pointed out in their patches so that they can fix them before one of the maintainers looks at it
  • new contributors, shorten the delay for getting feeback from the community about their contributions and keep them motivated

This BoF aims to be a first presidential "get together" to discuss PatchSquad-related topics like:

  • Goals for GNOME 2.19.x development cycle
  • Bugzilla additions (patch status, stock comments, stats pages, queries, etc.)
  • New documentation that needs to be written
  • Activities to get volunteers for PatchSquad

  • Collaboration with Bugsquad and GNOME Love
  • Any other stuff

PatchSquad wiki page: http://live.gnome.org/PatchSquad

Everyone interested in making PatchSquad a reality is invited to attend!

PS: I'll be doing some kickoff activities for PatchSquad in the next couple days and I hope it will get more attention from the community until GUADEC.

People are our most important asset - Why Organizational or Corporate Culture in FLOSS Organizations Matters

By: Anne Østergaard


The decision making processes vary from one Floss organization to the next. To get more people to join and enjoy working for our project we need to look at our people managing skills.

The way we organize ourselves is one of the keys to how successful our project is going to be.

Consensus decision-making is a different - and to many a new way to run an organization.

Consensus is about participation and equalizing power. It can be a very powerful process for building communities and empowering individuals - that is if we can avoid the most common problem and only use the method when it is suitable.

Practical Project Maintenance

By: Thomas Vander Stichele


This presentation is of the schizophrenic kind.

On the one hand, I will present ideas and tips about project maintenance, based on years of experience in maintaining a number of projects, from smaller personal projects to large projects like GStreamer, which contain multiple sub-projects. Ideas will also be taken from other free and open projects. The focus is on practical ways to add that elusive intangible ephemeral element we call "Quality".

attachment: project.txt http://www.guadec.org/files/project.txt

Project Mallard - The Future of Documentation in GNOME

By: Don Scorgie


For years, a new documentation format has been discussed. Finally, last year, our Fearless Leader, Shaun McCance, gave this project a name - Project Mallard (http://live.gnome.org/ProjectMallard). Since then, the Mallard umbrella has extended to include many subproject, ranging from the new (as yet unnamed) doc format, through a new meta data system (Spoon - http://live.gnome.org/Yelp/Spoon) to a new documentation editor (FoieGras - http://live.gnome.org/ProjectMallard/FoieGras). Work is now happening to make these a reality, with the first parts of Project Mallard due to debut in GNOME 2.20 (hopefully).

All of these technologies are aimed at making the job of documentation writers easier, help more useful and consistent to end users, improve documentation translations and promote documentation to "first-class" status within GNOME. This talk will give an overview of all the technologies under the Mallard umbrella, how they will improve the lives of everyone and what needs to happen to make the goal of "Documentation is a first class citizen in GNOME" a reality.

PulseAudio and GNOME, or: what's coming after EsounD?

By: Lennart Poettering


A more sarcastic title for this talk could be "EsounD, die! die! die!"

Desktop audio on Linux and in GNOME is a mess. There are just too many competing, incompatible sound systems around. Most current audio applications have to support every sound system in parallel and thus ship with sound abstraction layers with a more or less large number of backend plugins. JACK clients are incompatible with ALSA clients, which in turn are incompatible with OSS clients, which in turn are incompatible with ESD clients, and so on. "Incompatible" usually means "exclusive", i.e. if an OSS application gets access to the audio hardware, all ALSA applications cannot access it.

MacOSX has CoreAudio, Win XP has a new user space audio layer, both manage to provide comprehensive APIs that make almost every user happy, ranging from desktop users to pro audio people. Both systems provide fairly modern, easy-to-use audio APIs, and a vast range of features including desktop audio "bling".

On Linux and in GNOME we should be able to provide the same: a common solution that works on the desktop, in networked thin-client setups and in pro audio environments, scaling from mobile phones to desktop PCs and high-end audio hardware.

PulseAudio tries to be a solution for this problem, and already has come a long way, but there is also still a long way to go. In this talk I plan to illuminate a few aspects regarding the integration of PulseAudio and GNOME, where the infrastructure is still lacking, where we're already rocking. I also want to discuss how we can finally bring an end to the era of ESOUND in Gnome, what the next steps are, and especially, what the response will be in the future if developers ask "I want to write an audio application for GNOME, which audio API shall I use?"

For more information on Pulseaudio, see: http://pulseaudio.org/

PulseAudio is already part of a many of the big distributions, so you might have a chance to play around with it, by just installing the respective packages.

Talking experience: linux.conf.au and GNOME.conf.au 2007, and also an ad-hoc talk on PulseAudio at GUADEC 2006.

Real-Time Rich Text Collaboration

By: Marc Maurer


AbiWord is a fast and lightweight word processor which is suitable for (almost) all of your typical word processing needs. The core functionality has been heavily extended by plugins over the years, adding support for various file formats, math support, grammar checking, and more.

For more than a year now we are working on an exciting new collaboration plugin. This plugin allows multiple people to work on the same document in real-time. This removes the need to send documents over by email when you are collaborating with a group of people. The always tedious and error prone procedure of merging the changes from all group members (typically done by one person) will become obsolete as well.

While this sounds nice in theory, in practice there are a lot of hairy details to get right. This presentation will cover topics such as:

  • A high level overview of the architecture and protocol used; why it fits naturally in AbiWord's design

  • Interoperability, the (in)feasibility of it
  • How collisions are handled
  • How to handle undo/redo properly
  • How the transport layers work (currently a XMPP and a raw TCP backend exist)
  • How this found a perfect use-case in the One Laptop Per Child project
  • The future plans we have to make this work even more exciting

With some luck a short live demo of AbiWord collaboration in action will be presented.

Note: we'd love to hear which exciting new use-cases you can come up with!

Screensaver Sanity

By: Eric Anholt


GNOME has struggled with providing quality screensaver entertainment and power-saving modes using the limited tools provided to it by the X server. In this talk I will present new X Server support for giving the desktop better control of screen power management and entertainment modes, including back light control, application events for screensaver activation, and per-output screensaver inhibiting. The talk will include demonstrations of using these features on the GNOME desktop.

Speeding Up Libglade/Gtk-builder in Embedded Devices Using Shared Objects

By: Markku Vire


Using libglade is a convenient way to to separate the user interface from application logic. Interface is stored as a separate XML file, which is then parsed and interpreted at runtime. On a desktop system the costs related to this additional work are very small, but on embedded environment they can be significant.

I investigated earlier (see http://syslog.movial.fi/uploads/compiled-libglade.pdf) if libglade could be boosted up by compiling XML-files into shared objects and dlopening them at runtime. However, libglade API doesn't support new gtk techniques like actions and ui-manager. These can be defined by using Gazpacho, but loading files using these is out of reach for libglade. So, everybode is waiting for upcoming GtkBuilder.

This presentation will investigate if the similar techniques used speeding up libglade can also be used with the GtkBuilder, making the easy, flexible UIs also available for low-end devices.

Software development with Anjuta IDE

By: Johannes Schmid


The talk will introduce you to software development using Anjuta IDE. It will cover aspects such as project management, debugging, glade integration and symbol browsing.

It will try to cover development with GTK+ in C, C++ and Python by presenting in tutorial steps:

  • How to create a project
  • How to manage the files in a project
  • How to build your application
  • How to debug your application
  • And finally a short introduction on the more advanced features such as profiling, valgrind, snippets and using the symbol database.

Find out more about Anjuta: anjuta.org

Technical Challenges when using Electronic Paper Displays with GTK

By: Matthijs van de Water


Introduction into Electronic Paper Displays

An Electronic Paper Display holds significant improvements over LCD technology with regards to reading and writing. Instead of rows of glowing cells, e-Ink™ microcapsules appear as either black or white pixels depending on a positive or negative charge applied. Since these microcapsules contain only pigments, this means the display is 100% reflective (no backlight). The result is a reading experience that is similar to paper - high contrast, high resolution, viewable in direct sunlight and at a nearly 180-degree angle, with no power required to maintain the image. The technology currently supports 16 levels of gray at 768x1024 pixels with a resolution of 160ppi.

The drawback however is that the high screen stability greatly impacts the maximum refresh rate of this kind of display. A full-quality update of the entire screen takes just under 1 second. Because of this, there are some interesting challenges when designing User Interfaces and porting existing applications to a platform using such a display. It is these challenges and possible solutions at the GTK level I would like to show and discuss with the Gnome developers.

Problems when using standard Xorg and GTK

I will talk in detail about the main problems when using (as we currently do) standard components:

  1. Because of the low latency of the screen, it should only refresh to show its new state after the screen has reached a steady state (e.g. all redraw operations on the screen are completed). There are no reliable hooks for this yet.
  2. In order to keep the number of screen refreshes to a minimum, the use of highly interactive widgets should be avoided, or these widgets should be altered. This means (in our current solutions) for instance: no scrolling, no popup-menu's, etc.
  3. Asynchronous communication with X server makes it hard to know when a redraw operation has really made it into the Framebuffer.
  4. When multiple applications are visible on the screen (think: toolbar(s), input method, actual application) display updates become even harder to manage: only the application that is last to complete his redraw should trigger an update.

Current solutions in the iLiad

I will talk about our current architecture, which does not change or actively hooks into the X-server, Window Manager or GTK. I will talk about why this solution -- though very well tunable -- is far from perfect and greatly complicates porting of applications.

Discussion about integrated solutions

As iRex we have some idea of how to solve these problems, but since we don't have a lot of experience in GTK/Gnome development, we would like to discuss our views with the developers in the audience and start a discussion on how to solve this 'The Right Way'™. We are actively looking to working with Gnome developers and contributing to the Gnome project.


Telepathy How-To. Writing a IM/VoIP client in 20 lines of python

By: Raphael Slinckx


Telepathy is a relatively new framework abstracting the existing IM protocols such as jabber, msn, oscar. It is an API designed on top of D-Bus allowing desktop applications to easily add IM support as well as VoIP/Video capabilities.

This tutorial will explain the basic concepts behind the API. First an introduction to the specific objects used to represent connections and channels, followed by an overview of the existing components.

The second part will focus on writing a bare-bones IM client in python. This client will then be extended to support voice/video calls. Finally a simple UI will be built around this backend code.

The third part will introduce the mission-control component and how it allows any existing application to easily add support for communication code in a non-intrusive way, creating a presence-enabled desktop.

If time allows and the support for it has landed by the time guadec happens, I will introduce the collaborative feature of Telepathy called 'Tubes', that allows applications to send arbitrary data through existing telepathy connections, enabling applications to talk to each other in a simple way (only the application-specific protocol needs to be written, all the connection details are hidden)

The New Main Menu: An Interactive Alternative to Hierarchy

By: Jim Krehl


OpenSUSE 10.1 introduced a new main-menu for it's GNOME desktop. Since then many people and a couple of distros have picked it up as an alternative to the traditional GNOME main-menu. The new main-menu emphasizes dynamic organization of a user's applications and documents, relying primary on non-intrusive monitoring of the user's activity as well as a bit of user interaction. The new main-menu also integrates many other kinds of system entities. First, the new main-menu offers a generic search interface to access objects besides documents and applications such as emails or instant messaging conversations. Second, the new main-menu integrates intangible system objects such as network status.

This talk will focus on:

  • The scope of the new main-menu, or what the new main-menu is and what it isn't, e.g. why the new main-menu is not a replacement for the traditional, hierarchal menu.
  • The design of the new main-menu, or why does the new main-menu do this and not that.
  • The architecture of the new main-menu, or what does the new main-menu offer developers and how the main-menu avoids reinventing the wheel.
  • How the main-menu can be extended, improved.

The User Interface Specification - a document with many stakeholders

By: Tuomas Kuosmanen


Experiences and thoughts of drafting, designing, writing and maintaining user interface design specifications in a wiki environment, and how to edit them in a collaborative way with developers.

The web, the desktop, and Jackfield

By: Stuart Langridge


Applications are increasingly moving to the web and away from the desktop. The web's cool and the desktop isn't. Why? What can we do about it? How can we make Gnome cool again? Including discussion and a demonstration of Jackfield, Apple's Dashboard (and Google widgets and Opera widgets and Yahoo widgets and Microsoft gadgets) for the Gnome desktop.

Too Many Metas: A 10,000 ft. view on building a metadata desktop

By: Joe Shaw


A recent hot trend in the GNOME community is building a "metadata-enabled" desktop in which applications can display additional information about a given piece of data and things like tagging are built-in. Unfortunately with technologies like Beagle, Tracker, and Leaf tag and a multitude of file formats and data sources out there, there isn't a coherent view on how to build this desktop. While a common theme on GNOME development lists is a perceived urgency to solve "the metadata problem", no one has clearly defined what this problem is, or how solving it will improve our user experience.

In this talk, we'll first try to see if we can define what the "metadata problem" is, and why it's important that we solve it.

We'll take a look at a lot of the challenges facing us in building a metadata enabled desktop:

  • How existing technologies (like the ones listed above) come up short today
  • Why a single, universal metadata store is impractical
  • How applications that silo their data (like Evolution) make our lives more difficult
  • How a large amount of "implicit metadata" is lost by applications

We'll also discuss how metadata storage and desktop indexing are different but intimately related, how other desktops and operating systems are addressing the issue, and hopefully by the end we'll have at least a semi-coherent view of the work ahead.

Tracker and the next generation desktop

By: Jamie McCracken


Tracker is the cool new service on the block that can transform a sluggish and poorly integrated desktop into a fast, sleek and seamless desktop experience.

Tracker in not just an indexer as it provides a centralized and extensible metadata server which gives global access to all metadata and allows super fast searches on them too.

And with tracker, the same benefits that EDS gives to third party apps like Dates and Contacts can now be made available to all apps and across all services.

And thats just the beginning... find out how tracker can solve a lot of the problems that plague today's desktops including how it can give you:

1) A fast and efficient way to effortless share metadata, applications, bookmarks, history etc - its the ultimate data hub for first class objects

2) Desktop wide tagging

3) Desktop wide notifications of changes to metadata

4) A GConf replacement (there's actually very little difference between a metadata server and a preference server)

Usability Clinic

By: Calum Benson


Bring your user interface mockups, prototypes, personals, scenarios or other usability issues along to GNOME's usability gurus for an instant assessment. No win, no fee! (Otherwise, a beer would be nice.)

Thanks to Bryan and Máirín from Red Hat who've tentatively offered to help me run this session. Given the Friday@5pm slot, the format suggested by Bryan goes something like:

  1. Bring us your tired, your hungry, your poor GNOME apps
  2. We'll try to split up or work together to get a look at everyones screen shots / demos and give advice
  3. Switch off the laptops and continue chatting about improvements on our way to the pub :)

This session is intended to be for practical assistance/problem solving only. If you want to discuss what GNOME 3.0 should look like or when the next version of the HIG is coming out, please save it until at least step 3 above :)

use Gtk2 'init' - Introduction to the GTK+ Perl Bindings

By: Emmanuele Bassi


Since the Good Ol' 1.x days, GTK had bindings for the Perl language. In 2003, the gtk2-perl team began working on the bindings for the GTK+ 2.x series, as well as the rest of the GNOME Platform libraries. After almost four years Perl has one of the most complete (and thoroughly tested) language bindings for the GNOME Platform.

This talk aims to present programming a GTK+/GNOME application using Perl in a clean, maintainable fashion with the GTK-Perl bindings, using the full power of object orientation, complex data types and the 'TIMTOWTDY' approach of the Perl language.

Where's my monitoring at?

By: Andre Klapper


This presentation is about the quality status of GNOME outside of the code base. I intend to provide some statistics and figures on workload, feedback times and rates for working fields like Bugzilla, I18N, Release-Team and the in-between interaction processes.

I am not not able to provide a fully detailed description at this point, because some of the stats that i want to provide will not be trivial to gather or require a decent amount of manual work. Presentation length: I expect about 30 minutes.

So, why will this topic be of interest? Unlike every bigger $company, GNOME does not have much monitoring and controlling. I will identify and present some of the bottlenecks that GNOME has in its processes and its project organization, and discuss possible solutions with regard to planning and coordination, which will hopefully result in faster work flow and a better quality of our products.

X and Toolkit Hacker Synergyfest

By: Daniel Stone


At the moment, there is somewhat of a disconnect between X hackers and toolkit hackers. Each has a wonderful repository of obscure information and suggestions that would greatly help the others, but we don't have any interchange.

In particular, input will change radically with the release of X.Org 7.3, but I'm fairly sure the people who need to be dealing with this in the toolkits don't entirely know this yet. RandR 1.2 also changes the way we deal with screens fairly radically, and so on, and so forth.

I'd like to present this as a fairly open workshop, with anyone involved in either X or the toolkits contributing. The major areas of interest are input (Xi, particularly Xi 1.4 with input-hotplug and Xi 2.0 with MPX, and XKB), and RandR 1.2/Xinerama. Compositing managers and input redirection should also get a look-in if the relevant people are around.

In addition, if there's anything the general GNOME developers would like to get out of the X developers, now's your opportunity to show up, heckle, demand, and/or praise. :)

xcomposite, xdamage, xrender, gtk+ and you

By: Ryan Lortie


This talk will give an overview of the purpose and uses of the XComposite and XDamage server extensions. It will also talk about XRender in-so-far as it can be used to achieve fast server-side (possibly hardware accelerated) compositing (including IncludeInferiors render pictures).

The purpose of this talk is to give an idea of how to leverage some of these technologies for use inside of applications themselves (rather than just at the level of the entire desktop). Also discussed will be current limitations of GDK/GTK and other bugs that need to be worked around and how to deal with these problems.

Because this talk is about the mechanics of compositing, a side effect will be that additional understanding is gained about how top level (ie: desktop-wide) compositing works.

Xorg/GNOME Integration

By: Adam Jackson


This talk will cover the active projects and recent changes in Xorg, how they benefit Gnome, and what implementation and integration work remains to be done. Likely topics include input redirection, fast user switching, input and output hotplug, multi-pointer X, multi seat, XCB, Composite-enabled OpenGL and Xv, and all those other impossible projects. Though aimed at developers, this will also serve as a preview for users of what is to come, and hopefully will inspire new use cases, as well as incite us as developers towards finishing these projects.

GUADEC2007/Booklet/sessionsAbst (last edited 2008-02-03 14:45:58 by anonymous)