FOSDEM 2012

FOSDEM welcome and opening talk.

Welcome to FOSDEM 2012!

The time has come to make the switch from embedded Linux to embedded BSD.... In this talk we will focus on the building of embedded appliances in the BSD world, and more specifically on using NanoBSD to create FreeBSD images that run on embedded systems. In the stock FreeBSD distribution an application (script) called NanoBSD is present that takes a configuration file and builds an image for a flash disk which then can be used on an embedded system. A short cookbook will be presented on the steps needed to actually create the image, and deploy it. Also the in-system upgrading of the image will be discussed. The use case we will present is an Stratum 0 NTP appliance that serves as network time server using GPS with PPS synchronization. This appliance is capable of providing highly accurate time service to a network of servers and desktop machines, even when disconnected from the internet. The example will use a Soekris 4501 embedded board and an OEM hockey puck-style GPS device and some tricks to use the high-res timing on the board, together with a temperature controlled crystal oscillator. The contents of talk have previously been published by the presenter in ;login:. the USENIX periodical [1]

A short introduction to the Jabber/XMPP devroom.

BoxGrinder is a set of tools that help you grind out appliances: preconfigured disk images with the operating system and requisite software ready to run on a selected virtualization platform. With a simple text definition file and a single command BoxGrinder will build a lean appliance from scratch, convert it to a target format, and deliver it to your chosen infrastructure.

Virtualization has become almost ubiquitous in modern scalable infrastructures, with traditional dedicated hardware setups being replaced by multi-tenanted virtual environments. This change facilitates many of the beneficial properties of Cloud Computing, key amongst which is the ability to create small, function-specific appliances that enables system components to scale independently. BoxGrinder addresses the key problem of specifying and building such appliances. It manages complexities such as software installation, dependency resolution and remote service interactions on your behalf. Existing methods can an arduously convoluted, with poor repeatability and performance characteristics; wasting time and resulting in slow and bloated appliances. Such factors negate many of the motivating factors for embracing Cloud computing, and this is an obstacle that BoxGrinder is specifically designed to overcome. Coherent and simple to specify and run; yet fast to build and easily customized to any desired level of complexity. In this session we will cover the basic concepts of BoxGrinder, with discussion of techniques and use-cases that illustrate how best to utilise BoxGrinder's powerful feature-set. Finally, we will work through a live example, from text definition to a running virtual appliance. Ref : http://boxgrinder.org/

OpenStack is a common effort to produce open source software to implement scalable Infrastructure as a Service providers. What happened in the project since FOSDEM 2011 presentation ? This talk will quickly introduce what OpenStack is about and the changes over the last year: Growth, new core projects, continuous integration changes and what's coming up in the Essex release.

This talk will discuss our experience at [AdaCore](http://www.adacore.com/), one of only a handful of 100% Free Software companies. All of our commercial products are licensed under the GPL and other Free Software Licenses. People often assume that there is a conflict between the use of such licenses and the needs of a commercial software company. Our experience at AdaCore shows that on the contrary, the Free Software model can be very successful both for us as a company and for our customers. We think this model can be used in many other circumstances, and want to encourage free software enthusiasts to consider this model in other circumstances.

An Open Source / Open Hardware scheme for making security hardware as easy to deploy as passwords.

Brief Welcome to the new Legal Issues DevRoom

LibreOffice has many features for accessible authoring: it provides functionality to use the accessibility features of the OpenDocument Format (ODF), it supports export to tagged PDF (unlike most other free and open-source tools), it has extensions for exporting to digital audio books (odt2daisy) and Braille (odt2braille), and an extension for evaluating and repairing accessibility issues in ODT, DOC and DOCX (AccessODF). It also implements accessibility APIs to enable users of assistive technologies to use the office suite. However, there is room for improvement, both with regard to the creation of accessible content and with regard to the accessibility of LibreOffice itself. This presentation will discuss both types of issues. It will highlight bugs and feature requests that could be addressed to make it easier to create accessible content, and issues related to the support for accessibility APIs.

We're living in hard times right now. Most of the F(L)OSS projects suffers from lack of volunteers especially if they must donate a large amount of time to this project. My talk will show how you can plan better your community how to measure it, how to use tips and tricks from the commercial world and how to use some agile methods and tools to make you community kick-ass squad. * How to plan your community for next couple of months; (ex. We need 3 more people to join our translation effort) and Create the Flow – how a bug report goes from bugzilla to the the end of it’s life. (a.k.a kill the bug) * Define how to do it (ex. Troll the forums, create twitter campaign, contact universities, or something else?) * How to Measure it (How many retweets do you have, how many clicks, etc) and Why? * How to find patterns into your community and how to use them. For example – Most of the answers I receive to my mailing comes during business hours OR Friday is not a good day to send emails * What is Agile and how to use it to make my community life easier? ( Trello show-case )

tba

Running a web application that is used by people from all over the world means that you cannot afford any downtime. However, the codebase and the database schema constantly evolves, while at the same time hardware failures may happen. The talk will try to present ways that we, at transifex.net, use to deal with the following two issues: - schema changes - hardware failures in order to achieve 100% uptime. The talk will discuss tools that PostgreSQL provides, like functions and triggers, and how they can be used to deal with schema changes and how to setup streaming replication for fail-over.

One part of the integration of upstream software in a distribution is to correctly deal with changes that have a wide impact, either because they affect a lot of other software, or because the changes will be highly visible to the users. And it is easy to feel that such changes are always going wrong: some applications stop working, many users complain about the change they feel was uncalled for, nearly nobody shares a thank you note. Such wide-impact changes always come with controversies, and being the bridge between users and upstreams, distributions are the place where all the rage is going on, with a social aspect that is usually at least as important as the technical side of things. The recent years have not been exempt of controversies, and we will share our experiences with user-visible changes such as the move to KDE 4, GNOME 3 and systemd. This talk will be co-presented by the SUSE Gang: Frédéric Crozat, Will Stephenson, Vincent Untz.

Brief Welcome to the Free Java DevRoom

There are millions of users running a Debian-based Linux distribution. Increase distribution of your hottest Mono apps by making them available in .deb format. Learn the basics, caveats, gotchas, and fastest shortcuts involved in making distribution-integrated packages for Debian and Ubuntu

Welcome to the crossdesktop devroom!

Updates from the Intel userland: GL, X, and infrastructure. Much has changed for the better in Linux graphics in the last few years. The radical changes driver architecture to make compositing possible are stabilized and mainstream, new desktop environments are popping up regularly making use of these features, and OpenGL is changing from a usually buggy luxury component to a standard working part of Linux. In this talk, Eric will cover what has been going on in the Intel graphics driver stack to stabilize Linux graphics and catch up to the capabilities of of the hardware.

Open content licences are tools at the disposal of creative people who want to use their copyrights in a permissive manner. Their first aim is to allow the sharing and spreading of works, by granting rights to the users on a royalty-free basis. However, these licences remain binding legal documents, according to which licensees must respect some obligations, and which are enforceable before courts. The proposed presentation aims at providing an analysis of interesting court decisions where open content licences were at issue. Please review the links below for background information:

A review of the recent past, a summary of current work on JDK 7 and JDK 8, and a look ahead to upcoming improvements in both governance and infrastructure.

Where we have started from, where we are going to. For hackers, and for mere mortals.

A rapid-fire introduction to Jabber and XMPP, with plenty of opportunity to ask questions of the XMPP experts!

Topics covered: * Why the hell on OpenBSD * How easy it is to create a new GNUstep port * What's new compared to last year * Problems I encountered over the last year * Goals for the next year

GStreamer is a highly versatile plugin-based multimedia framework that provides abstractions to cater for a whole range of multimedia needs, whether desktop applications, streaming servers or multimedia middleware; embedded systems, desktops or server farms. GStreamer 1.0 is the next generation of the successful GStreamer 0.10.x API series where some of the core API has got a complete overhaul to address many of the limitations we have run into over the years with the old API. In many respects, 1.0 will be pretty much the same as 0.10, but in others it will be radically different. This talk is a high-level overview of what's been happening in the world of GStreamer as of late, with a special focus on the status of GStreamer 1.0, highlighting some of the improvements it will bring.

Mer says it is "aimed at device manufacturers" - but what does this mean? It has the same source as many other distros so this talk will introduce the non-code areas where Mer differentiates and how it does that by operating in the open. From systems and tools to processes; what's available, what Mer does and does not address and how a Mer-based project gets going?

When changing laws threaten the FOSS community, it pushes back with activist campaigns lead by NGOs and non-profits. These campaigns look much like the ones conducted by other groups of activists such as the human rights network. When FOSS gets political, it typically uses a handful of common strategies. This talk will build on information gathered from interviews and other research to describe what techniques free software advocates use when they try to influence government policy. It will briefly evaluate their effect, taking examples from the ACTA campaign and from the reaction to proliferating three-strikes laws aimed at enforcing IP policy. Then it will compare with other activist projects in other fields: FOSS advocates might expand their vocabulary of political action by borrowing the approaches used in other issue areas.

The plans for Firefox in 2012 are huge. However, hacking on Firefox has a huge learning curve, and requires specialists with experiential knowledge of a sea of undocumented code and familiarity with a host of implicit behaviors that are impossible to predict. The risk of regression, even after years of requiring tests, is still quite high. New features continue to take far longer than we expect, and we continually rely on the same small group of people to develop them, and an even smaller group to review them. How can we make the development of Firefox easier for new contributors, as well as ourselves? I'll talk about new approaches towards feature development and contributor interaction that can reduce the time required and risk involved in Firefox development.

In this talk you'll learn how the JDK 7 Updates Project in OpenJDK works, and how to work within it, how to track changes, get your fixes in, and follow along as for example the Mac OS X Port gets integrated into future JDK 7 update releases.

Debian has a number of legacy tools (that's a euphemism for ugly hacks) that are not addressed due to inertia, fear of breaking stuff, and the difficulty of reaching consensus for changes with cross-package impact. I'll talk about dealing with the above issues in the context of ongoing work as part of Debian Enhancement Proposal 9. Specifically, the talk will cover how (not) to make proposals for cross-package changes, and how to map behaviour in a technical spec to feature-centered assertions in a test suite.

This talk will include an introduction to OpenStack Nova's overall network architecture, as well as an introduction to the anatomy of one of the services that make up Nova. Finally, I'll give a give an introduction to Eventlet, the event library we use in all of OpenStack. In short, this talk should help you dive into most parts of Nova and not feel like too much of a stranger.

A 45 (or less) minutes session dedicated on explaining how we proceeded in writing our Visio import filter and showing a methodology how to write an import filter for LibreOffice efficiently. Part of the session will be dedicated to get interested developers started. If you want to join our exciting journey, this is the door wide open for you into our community.

CESeCore is a common criteria certified security core. It is a developer library, including support for hardware cryptographic devices, of JEE components and was recently certified at Common Criteria level EAL4+. This talk will give an overview of what CESeCore is and what it can be used for. It will also share experiences about Common Criteria certification, what it is, what's good and what's bad, and challenges involved for open source software.

The Openmoko Freerunner, the open source and HW mobile phone, is alive and kicking. During this talk we provide a status of the current active and stable platforms ported to the Freerunner (SHR, QtMoko, Android and Debian).

The community is also producing the newcomer with codename GTA04. The device is already available for pre-ordering. The new phone is 3,75G enabled, has superior characteristics compared to the Freerunner (GTA02) and fits in the current Freerunner casing. During the talk we will shed some light on the status of the project.

IKVM.NET is an implementation of a Java VM on top of Microsoft .NET and Mono. In this talk I'll describe how Java 7's JSR 292 invokedynamic and MethodHandles have been implemented in IKVM.NET.

Modern software is typically composed of numerous components, such as third-party open source packages. To prevent legal or security problems, software vendors must identify the components (including their licenses) used to create the binaries they ship. This requires knowing exactly which source code files and other artifacts are used to create a given binary, and how they are used (e.g.whether libraries are statically or dynamically linked). In this talk I will we show a generic method to reverse-engineer this information from the build processes of software products. The method traces system calls to determine the composition graph of sources and binaries involved in build processes.

SQL/MED is the new frontier of PostgreSQL ! Since the release of PostgreSQL 9.1, we see lots of Foreign Data Wrappers (FDW) coming out, giving you the ability to connect your database with multiple data sources : local files, other RDMS, NoSQL stores, webservices, etc. The primary language to write a FDW is C. But a recent extension called "Multicorn" makes Foreign Data Wrapper development easy, by allowing the programmer to use the Python programming language. This talks will : * Explain the basics of SQL/MED * Give an overview of the various existing Foreign Data Wrappers * Show how to code a wrapper in a blink of en eye with multicorn

* short history of OpenGroupware, overview of its features * porting effort from gnustep-make 1 to gnustep-make 2, and from libFoundation to gnustep-base * OpenGroupware is now based on SOPE fork from the SOGo team, lots of bugs in SOPE got fixed * talk about some new features * OpenGroupware-5.5rc1 (I hope to agree with Adam to release it even before the FOSDEM) * short Demo

This talk will cover two topics, input methods and multitouch support. Input methods are a particularly ill-understood, but hugely important, part of the X input system. Any input more complex than 'this key produces this symbol', such as Compose keys or phonetic input for Asian languages, is handled by client-side support code. This talk will give an overview of input methods in X, going through the standard protocol as well as some popular implementations, along with some ideas for future work. Multitouch support is a hugely attractive buzzword for many devices and form factors. Multitouch support claims to allow for intuitive interactions but so far has largely been limited to custom implementations. With the upcoming X Server 1.12 release, we now have generic multitouch support alongside traditional pointer/keyboard input. This talk will explain the fundamental principles, new event types and how the server behaves when multitouch input devices are present.

With XMPP you can build a webchat in a breeze, so nothing can go wrong, right?

The HelpIM chat software is about 10 years old now. We have rewritten it three times and with each rewrite we managed to make some major screw-ups. Recurring issues are: "how to reliably deliver the chat over the web", "how to route the messages within the server" and "how to authenticate over both HTTP and XMPP". With this talk I will save you from making the same screw-ups as we did.

Know some C++? Hacking on the Mozilla platform is a great way to fight for the future of the Web. Talk includes development mechanics, architectural overview, and strategies for keeping things manageable. Some C++ knowledge recommended.

The state of the Mono project in the year 2012. Will give an update on the progress of Mono and the Mono 2.12 release, which is a major release containing a year worth of improving

IIO (Industrial I/O) is a new kernel subsystem to allow easy userspace interaction with data capture devices (ADCs, DACs, accelerometers, light sensors, etc), while maintaining a high level of performance. Based on a recent driver contribution using this subsystem, we will detail how to build a simple driver using this subsystem and explore how to use advanced features like triggered captures or buffering. We will also explore IIO user space API and how to use it.

Better planning algorithms can help save the environment, reduce costs and improve service quality. All organisations have planning problems, such as employee rostering, task scheduling, vehicle routing or bin packing. Yet, they hardly optimize those problems. Why? Because those problems are “NP-complete”: computationally very difficult and humanly impossible to optimize. Drools Planner optimizes such planning problems for normal Java programmers.

It implements a series of optimization algorithms which can optimize any planning problem: heuristics and metaheuristics with fancy names such as “First Fit Decreasing”, “Tabu Search”, “Simulated Annealing”, … The input and output are plain old java beans (POJO’s), so it’s easy to integrate with JPA, JDBC, JSF, ... The constraints are expressed as Drools Expert rules, so adding extra constraints is object-orientated and scalable. And it’s easy to get a Planner project started with the detailed reference manual and many examples. In this presentation, Geoffrey De Smet (Drools Planner lead) will explain the nature of planning problems, go through an entire Drools Planner example, show some demo’s and compare the results of different optimization algorithms. Ref : http://www.jboss.org/drools/drools-planner.html

The OSI (Open Source Initiative) is reorganizing its governance from a board-only organization into a member-based structure in 2012. Simon will give us a brief explanation of what that is, what it means, and how to join.

Welcome to the Ada Developer Room at FOSDEM 2012, which is organized by Ada-Belgium in cooperation with Ada-Europe.

Ada-Belgium and Ada-Europe are both non-profit organizations set to promote the use of Ada, and to disseminate the knowledge of it into academic, research and industrial establishments in Belgium and Europe, resp. Ada-Europe has member-organizations, such as Ada-Belgium, in various countries. More information on this event is available on the Ada-Belgium web-site (see link).

Overview of the main features of the Ada language, with special emphasis on those features that make it especially attractive for free software development.

Ada is a feature-rich language, but what really makes Ada stand-out is that the features are nicely integrated towards serving the goals of software engineering. If you prefer to spend your time on designing elegant solutions rather than on low-level debugging, if you think that software should not fail, if you like to build programs from readily available components that you can trust, you should really consider Ada!

Dialogs in LibreOffice are horrifically ugly, mostly because all widgets contained within them and the dialog themselves are typically fixed size and sized to contain the text of the longest translation. The other reason they are ugly is because they are so painful to edit. There's been plenty of proposals and attempts to fix them. Here's another one.

Bill Hoffman, the original CMake developer, and Alexander Neundorf the architect of the KDE CMake Build system will talk about the full capabilities of CMake as a build tool. They will cover both the basics of getting started with CMake, and some really cool features that allow for the cross platform building of entire packages of software. This will be demonstrated with example projects using the gtk as well as the Qt toolkit. They will also give some interesting historical notes on CMake. Covered topics will include: * The basics * Debugging your CMake build system * Integrating 3rd party packages in the build using ExternalProject * Creating source and binary packages using CPack * Continuous Integration testing with CDash/CTest and cdash@home * Installing your CMake-based library - exporting and importing targets * Cross-platform scripting with CMake (cmake -E, cmake -P, file(DOWNLOAD ...) ) * Lots of fun historical notes on the development of CMake and the KDE CMake build system

Stories on complications of combing works under different software licenses.

Qt has had a support for embedding accelerated native OpenGL code inside Qt applications, but hardware graphics acceleration has been always a bottleneck on Linux platforms due to lack of proper support and driver openness. The situation is getting better every day, and with hard effort there are now several hardware acceleration capable Linux devices either in the market already, or coming in a few months. Combined with capabilities of Qt version 5, including QML SceneGraph and OpenGL Shaders in QML called ShaderEffects, the possibilities are endless. 2D or 3D UI's with 60fps on a mobile Linux device is not only a dream these days.

Qt framework has been popular amongst desktop developers already more than a decade. In few last years it has been gaining similar popularity amongst mobile developers. Since Qt is well supported on many mobile Linux platforms, including Maemo, MeeGo, MeeGo Harmattan and Mer, it has become a first class citizen on mobile Linux devices. The project presented here (has no name yet) has an aim to form a vibrant community to create a free and open sourced resource collection of QML Shader Effects for 2D and 3D to be used freely in stunning mobile device UI's of devices as N9, N950 or Raspberry Pi.

Looking at some easy hacks - some worked examples in getting started in the LibreOffice project. We have a ton of entry level tasks, all of them useful that we'd love to get people involved with. We also have some more juicy, but still really useful things we need to get done too.

libguestfs is a set of tools for accessing and modifying virtual machine (VM) disk images. You can use this to inject files, resize, rescue, create, view or audit disks. libguestfs is also a library that you can link to management programs written in C, Perl, Python, Ruby, Java and other languages. In this talk, Richard Jones will introduce the tools and give live demonstrations. He also talks about how they work behind the scenes.

Lambdas in Java 8 will be the first major addition to the Java language since the Generics in Java 5, while programming with a language that support lambdas/closures is way cool, there are several traps and pitfalls to their introduction in Java. This talk will explain the VM modifications already done and that will be done to support lambda in the JDK 8.

Use Mozilla's Addon SDK to quickly create Firefox extensions to improve your web browsing experience and integrate with Social Media. We will show you how to use your JS, HTML & CSS skills to modify a target web-site and integrate it with Firefox using the unique capabilities of the SDK.

We believe system (and distribution) development needs to be re-thought from the basic concepts upwards. We've implemented some ideas for streamlining development, reducing development friction, speeding up system upgrades and adding support for downgrades and rollbacks, and generally making development of entire systems faster and more fun. At the level of individual, atomic projects, several great tools and development methods have been developed over the past decade or so. Few of them are applied at the system or distribution level. The Linux kernel development, for example, greatly benefits from the ease of branching and merging that git provides, but it is not possible to branch and merge the whole system, or distribution, consisting of hundreds or tens of thousands of individual projects. From the agile development worlds, automated testing, test driven development, and continuous integration are common-place for individual projects, but not so much for complete systems development. Would it not be nice to have them? Packages have been the darling child of Linux distribution development since the early days. They are a natural, modular concept, and have been one of the key factors behind the success of the distribution concept. Package managers have made it easy to install and remove and upgrade each piece of software separately, and to upgrade the whole system by upgrading each installed package. However, a modern distribution consists of tens of thousands of packages, and the combinatorial explosion of dependencies and interaction may be getting out of hand. In this talk we explore another way of approaching the packaging problem. We believe these and other changes are useful for bridging the current gap between upstream development and end users, to speed up system and distribution development, and to let system builders bravely hack what no-one has hacked before.

How to use a combination of XMPP PubSub and MUC to have Web widgets communicate with each other on the example of Personal Learning Environments.

In the domain of Technology-Enhanced Learning (TEL) a current research focus is on widget-based personal learning environments (PLE). Learners mash-up their favorite Web widgets to complete learning applications running in any Web browsers. Furthermore, learners socialize, communicate or even collaborate with their peers using real-time technologies. In the context of the EU large-scale integrating Open Source project ROLE (Responsive Open Learning Environments; http://role-project.eu; http://sourceforge.net/projects/role-project/), we employ XMPP in combination with recent Web technologies (e.g. XMPP over WebSocket) on a wide basis to realize communication and collaboration use cases within such browser-based PLE. Beneath the usage of regular features such as roster lists, online presence, IM and MUC we developed a framework for Interwidget Communication (IWC) based HTML5 Web Messaging (local) and XMPP PubSub (remote) as well as a payload format inspired by Google Android Intents. Developers can thus design their widgets to communicate with each other even across multiple users and browsers. This framework can optionally be enhanced with trust-awareness features. In this talk we present the results of our work with a focus on remote interwidget communication and report on our experiences with XMPP over BOSH/WebSocket.

* it will feature GAP (GNUstep Application Project) * introduce the project, and its goals * cover some of the applications found there * it will also include the usual known suspects: GWorkspace, ProjectCenter, Gorm, ... * it will also cover some other nice GNUstep applications found scattered all over the web, for example: * CDPlayer, Burn, GNUMail, SimpleAgenda, Zipper and more * show/demonstrate some of the applications live

This session will provide a basic intro to Tizen and will talk about the community transition from MeeGo to Tizen. We'll do a quick recap from past year of the MeeGo community along with some things we learned along the way. The rest of the presentation will talk about what we are doing to form the Tizen community and how you can participate. I'll also gather feedback during the Q&A on what you would like to see us do differently in the Tizen community.

Using Ada to provide business logic, and glue existing applications together.

The children's game universe "Crimeville" from the game developers Art of Crime challenges the players to solve detective riddles cooperatively. In the on-line version of the game this means that the players in each session of the game can chat with each other. To help the children write better - and to limit them being naughty - the chat is going through a language server written in Ada. The language server uses pre-existing Open Source spell-checking components glued together with application logic written in Ada. The application is a nice example of a small network server and of using parts of the POSIX Ada API (FLORIST). The presentation will cover the requirements from Art of Crime in broad terms, describe how this was achieved using publicly available Open Source components, and how using Ada helped convincing the customer that the system actually does its job.

Q&A session with core organizers. *The* opportunity to get in touch with us, to ask questions about organization aspects, to tell us what you love or hate, and to discuss anything FOSDEM related.

Everybody in the FOSDEM staff is a volunteer. We do this because we care about open source, and especially about the community. What we do can be considered a kind of FOSS/community project. Hence, we love getting feedback and being in touch with the community. This session is created for that purpose. Come and talk to us!

The webinos project (http://webinos.org/) aims to deliver an open source open standards based platform for secure and privacy aware interaction between users and services. Developers program in JavaScript and get access to both local and remote services. Under the hood, the webinos runtime uses XMPP to do service discovery. This talk highlights some unique features of webinos and investigates the role of XMPP.

Cairo is the drawing API that is used predominantly by the GTK stack along with Firefox and couple of ports of WebKit. It is designed as a comprehensible page layout API rather than as a high performance interface to the GPU. It is Cairo's job to bridge the gap between an easy-to-use drawing model and efficient rendering. This is not always as easy as it sounds... The talk will present the origins of Cairo, its successes, some of its failures, and the promising technologies for the future.

Due to the nature of the new SoC architectures the Power Management needs a new model for the various system latencies. The talk presents: - the concepts of system, devices, wake-up and resume latencies, - the recent changes in the devices framework for the latency, why and how to make it generic, - the recent changes in the ARM/OMAP platform code for the system latency, - the problems encountered while modeling and measuring the various latencies, - a proposal on the model, - the planned changes in the device framework, the platform code and the APIs. This talk is oriented towards Linux power management developers and users. The generic model covers all flavors of Linux, from the embedded device up to the multi processor computing server.

You're using IaaS to build a large scale, multi-tenant, hosted service. At the end of the day, you're hosting other people's code in some form. Your environment needs to be dynamic to properly utilize IaaS capabilities and meet user expectations. You need it to stay secure and controlled. Your users need to stay isolated from each other without feeling restricted. You need to control orchestration, workload management and security. You need to orchestrate to respond to changes in scale or failures at the IaaS level. You need workload management to control the resources a single user can consume and how contention is managed. Lastly, you need users to have access to as much as possible so they feel in control without risking your control of the overall system. This talk will show by example how Red Hat's OpenShift Platform-as-a-Service uses MCollective for orchestration, SELinux for segmentation, Linux Control Groups for workload management and some core operational fundamentals applied to cloud architectures to tackle this challenge.

Ref : https://openshift.redhat.com

Multiarch is a properly generic solution to the installation and use of library packages from one than one architecture at a time, which changes the way running non-native binaries and crossbuilding are dealt with in a fundamental way. It is both powerful and intrusive and has taken a long time to make happen. This talk explains what it is, how it works, and what you can do with it. We will also discuss future adoption by other distros.

Red Hat Cluster Suite is a robust technology that is used at many areas. PostgreSQL can be directly used with Red Hat Cluster Suite, in order to create an active-passive clustering environment. In this session, we will setup a two-node cluster, learn how to configure it, also talk about some more details.

An open source and open standards based PKI project. Overview of subsystems ((CA, OCSP, KRA[key-recovery-archival] )

"Pacemaker Cloud" is a High availability manager for cloud providers, which detects and isolates failures, restarting components when required.

Come and hear how the LibreOffice QA team works, get hands on experience with bugzilla, find out where our daily snapshots are, and how to use them, and chat with fellow QA guys. See some feedback on the progress of bug tracking and some pretty graphs.

Univention Corporate Server (UCS) is a Debian-derived distribution focused on enterprise environments and heavily based on LDAP. In contrast to most other Debian-derived distributions it is based on Debian stable instead of snapshots from Debian unstable. With it's earliest development roots dating back ten years, UCS is now used in approx. 700 installations with the biggest having 80,000 users.

This technical talk will cover the following topics: - Basing on Debian stable: Benefits and challenges - Introduction to a few features specific to UCS: * Template-based configuration management with Univention Configuration Registry * "Listener/notifier" domain replication * Synchronisation of OpenLDAP and Active Directory using the Univention AD Connector * Web-based administration with the Univention Management Console - UCS is the first distribution to include Samba 4 in a supported product The talk will provide an overview of the supported features, e.g. assigning group policy objects to Windows clients.

Greenlightforgirls.org is a Brussels-based, international NGO promoting science, technology, engineering and mathematics to girls of all ages and backgrounds. We promote female role models from technical sectors to youngsters, and run events which inspire girls to study and pursue careers in technical areas, including computers. With this knowledge, we believe girls will save the world! As EU Director and global Technology Chair of the greenlight for girls foundation I aim to: 1. Create awareness about the need to attract more youth - especially girls - to computer science-related studies and careers, and science/tech sectors, in general; 2. Showcase the global activities of our foundation (20 events around the world in just our first 1.5 years in existence); and 3. Seek support from the global FLOSS (women?) developer community for g4g initiatives specifically requiring their involvement to succeed.

The basics of programming by contracts and how contracts were introduced in Ada 2012.

Ada 2005 already had assertions. The notion was considerably extended in Ada 2012, with pre- and post-conditions and type invariants. Together with other properties of the language that separate clearly interfaces from implementations, these new features provide an accurate description of the obligations and expectations of the user and of the provider of software components.

Buildroot is a nice, simple and efficient tool to build small to medium sized embedded Linux systems. It to automates the process of building a cross-compiling toolchain, the root filesystem with all userspace components, a Linux kernel image and a bootloader image. It is used for embedded systems ranging from industrial controllers to hand-held media devices.

Tons of things are changing around Internet users: the rise of mobile and tablets, appstores, and social networks, the adoption of the cloud. How is users' freedom protected in such an environment? What are Mozilla's initiatives to help?

A new project whose distinguishing feature is not reinventing the wheel.

Recently, Dave discovered a batch processing protocol called Hututupuh. Looking into it (it's apparently quite popular), he noticed a habit of Hututupuh developers to reinvent often key areas, such as endpoint identifiers, authentication, and notifications. Since the XMPP world has had these working just fine for quite a while (usually by reusing things like SASL), Dave wondered what would happen if you let XMPP do some of the heavy lifting. Hututupuh developers will, now doubt, rejoice at having a simple, ready-made solution available to them, with a pre-existing global infrastructure and wide support.

The presentation will describe the state of the OpenNebula project for data center virtualization, with a focus on the different innovative projects and infrastructures using OpenNebula as a platform for innovation and interoperability. We will show how OpenNebula integrates with other projects in the cloud and virtualization ecosystem and the potential areas for collaboration.

This talk is about taking pictures from above with a big latex balloon, helium, strings, duct tape and CHDK, and making a nice video with the pictures using python, GStreamer and OpenCV.

Some friends of mine and I got pretty busy last year on a crazy balloon photography project. I want to share that experience, say what worked (helium, CHDK, GStreamer) and what didn't (crazy kite-balloon ideas, arduino connectivity, and some other things, all due to a lack of time). Hopefully, that would motivate hackers to get out of their basement and go do cool things under the Sun.

I've written a modest desktop application to manage my Altus Metrum rocketry electronics. The first implementation used C and Gtk+. I eventually gave up on that implementation and started over using Java and Swing. The application now consists of about 25kloc using a collection of external java packages for things like speech synthesis, graphing and mapping. This presentation will describe what my experience with Gtk+ was like and why I was motivated to start over.

* New features in the text system this year * Resolution Independence/scale factor support * Other graphics improvements * Demo

Nexenta has had their own distribution since their inception. Now with the move to an illumos core we are launching a new distribution with an illumos kernel and debian packaging.

Explaining the upcoming hacks / improvements in the extensions- and specially the template-center.

Walkthrough for a successful X509/PKI deployment with free software.

The Java type system is unsafe since it allows covariant use of arrays. For example, an array of Bananas can be used where an array of Fruit is expected, given that Banana is a subclass of Fruit. This allows the following unsafe code: Banana[] bananas = new Banana[5]; Fruit[] fruits = bananas; fruits[0] = new Apple(); // runtime exception bananas[0]; // Apple? In the above example, the programmer gets back an Apple where he was expecting Bananas, causing an undesired runtime exception. We investigate the covariant use of arrays in open source Java programs to see whether programmers use this problematic feature of Java. We make use of the freely available OpenJDK, modifying its Java compiler to disallow covariant use of arrays, thus reporting any such uses as compile errors. We apply this compiler to a code corpus of 106 open source programs, including large and well-known programs such as Eclipse, JUnit and Ant. Initial results of our investigation show that covariance is rarely used outside the context of legacy code and Java libraries. This leads us to question its relevance in the Java language. In our talk, we also discuss solutions to covariance taken by other languages such as Scala and Google Dart, explain our modifications to the OpenJDK Java compiler and report the full results of our study.

In this talk, I will share my experience of building a real-time WebApp using XMPP on server side.

Gluon is an open source database schema analysis and entity/relationship mapper that easily integrates into MonoDevelop. Using the MonoDevelop addin you can browse databases, select tables, generate entities (including bulk rename operations) and add the generated C# code to your project with a couple of clicks. If my cats will help with the coding it will probably support schema migration (from inside MonoDevelop) well before the FOSDEM. If they don't help there will be enough to talk anyway (and nice catfur dolls for everybody).

Women & Mozilla (WoMoz) is a community driven project that aims at improving diversity and giving more visibility to women within Mozilla and FLOSS. This talk will be the occasion to go over the different projects that were launched since WoMoz was created: education, conferences, workshops, mentoring... are only a few of the areas that we've covered over the past year. This will also be the opportunity to engage in a discussion with the participants, in order to know how we can continue growing, and to gather ideas and feedback for future projects in the years to come.

The Nokia N9 phone has recently been released to the public, running the shiny MeeGo 1.2 Harmattan. External developers were able to get such devices via several mediums. Qt is at the center of this platform. It provides a great set of tools and libraries that make this device very accessible and give an excellent way to learn Qt development; also to experiment with KDE Mobile application development. In this presentation the KDE Mobile development workflow will be presented. Practically almost everything you need to know about how to make or port a KDE application for those gadgets and how to make the most out of the development tools.

During the presentation, there will be some notes about general hints and the development environments potentially available. We will see how to package your KDE Application for testing and later publishing. You can pick up technical tips and tricks for free that others have already spent a decent amount of time with. There will be some practical hints about application testing methodologies, and in general how to survive with the security framework from an authorized person regarding the topic. Last, but not least: you will see how to cooperate with Ovi store and their QA requirements. We will also have a look at the newly formed "Apps For MeeGo", community driven store. In other words, the idea of the publishing story. Speaking of which, the Community OBS will also be presented along with the fallback KDE repository for distributing packages for developer purposes. In the end, we will have a small demo session about the already available KDE applications for this mobile handset platform.

Android is rapidly becoming the primary vector through which open source software is entering into people's life, with new devices being announced almost daily. Unfortunately companies are cutting many corners, especially when it comes to licenses and quality assurance, because everyone is rushing their devices to market. The consequence is that many Android devices out there are not compliant with the licenses, with significant legal risk as a result, even though it is completely avoidable with a small investment in time and knowledge up front, saving a lot of time and money down the line. In this talk I want to highlight a few common violations, shatter a few myths about Android and provide some hints on how to improve the situation. This talk will not be about software patents

MultiPath TCP, a major extension to TCP, allows the simultaneous use of a smartphone's 3G and WiFi interface to increase throughput and better resilience. We implement MultiPath TCP in the Linux Kernel, publicly available at http://mptcp.info.ucl.ac.be

TCP, the most used Transport Protocol on the Internet, does not allow the simultaneous usage of multiple Interfaces. Smartphones with 3G and WiFi interfaces would benefit from a simultaneous use of both interfaces. MultiPath TCP is a major extension to TCP, allowing the use of multiple Interfaces for a single data-stream, without the need to modify the applications. This allows an increased throughput and better resilience to failures. The IP Networking Lab (http://inl.info.ucl.ac.be) of the Université Catholique de Louvain is implementing MultiPath TCP in the Linux Kernel. The publicly available source-code (http://mptcp.info.ucl.ac.be) modifies/adds about 10000 lines to the Linux Kernel's TCP-stack. The implementation has shown very good performance. For example, a throughput of up to 15 Gbps across two 10 Gig interfaces, whereas regular TCP can only use a single interface and thus 10 Gbps. We are now considering inclusion in the mainline kernel and would like to encourage people to test our implementation and/or submit patches to help improving it.

This talk covers the desing of dma_buf as merged into Linux Kernel 3.3 and deep-dives into some of the technical issues that make buffer sharing non-trivial. It will also explore what's definitely still missing and look at what crazy stuff still might come to dma_buf in future.

The legal structures of free software projects go through phases of popularity reminiscent of fashion trends. The early days of free software were decentralized and individualistic, partially inspired by the "free culture" movements of the '60s. Over time, centralization and incorporated non-profit organizations grew popular, parallel with a period of time where FLOSS was struggling for recognition as a viable alternative to proprietary solutions. As FLOSS crested that wave, and won the recognition of the business world, people began to recognize an over-proliferation of special-purpose foundations, and the conservancies (foundations that host multiple independent projects) came to the fore. In the past year we've seen a movement back toward decentralized individualism, questioning the need of any formal legal structures. The fact of the matter is that free software and international law work just fine for a whole gamut of legal structures, from the lone individual hacker to the largest of incorporated entities. It's a free choice for each project. The important thing is for every project to think through their legal strategy. Not just the "What?" (-license? -contribution policy? -legal documentation?) but "Why?" (-pick option X over option Y? -are we doing this? -do we care?) and "How?" (-can we make this work for us? -will this affect our users and developers?).

There will be many improvements to multi-CPU scalability in the upcoming 9.2 release. This presentation gives a sneak-peek preview of the changes that have been made, and presents the current status of PostgreSQL scalability.

A presentation of Ada's features in the parallel/multicore area, given in such a way that people can start experimenting and doing "interesting stuff".

Ada had built-in support for parallel programming from the start, and the successive standards keep improving that support, up to most recently for the new multiprocessor architectures. An overview of the support that already existed in Ada 83 and Ada 95 will be given, with practical examples so participants can try out some simple things first. Ada 2012 comes with interesting additions for using multiprocessors effectively. Embedded systems can use an extension of the Ravenscar profile to achieve analyzable real-time behavior on multicore platforms. Ada's dispatching domains achieve flexible allocation schemes for high-performance computing.

Project-Builder.org is a GPL v2 tool designed to help projects developers producing easily packages for multiple OS and architectures, on a regular basis, from +a single source repository. The various aspects covered by the tool are: - only produce software packages (ease integration in deployment servers, provide inheritance mecanisms, ...) - ease the various steps of solution life cycle (controlled impact of installation/uninstallation, dependencies management, identical deliveries up to customer, +announce management, web site delivery, metadata management) - help projects packages provisioning (templates/skeletons, generated structure) - Avoid code/metadata duplication (macro system, separate repository) - Neutral (repository, system, package type agnostic)

Reduces cost by providing process, method and tools to realize continuous packaging during the whole project life cycle. Today the tool supports: - Muliple repository (tarballs, SVN, CVS, Git, Mercurial, SVK...) - Multiple systems ((RPM Linux, deb Linux, ebuild , Solaris pkg) - Multiple build environments (local, VM, VE) - Multiple repository manager (yum, urpmi, apt) Used by MondoRescue, LinuxCOE, itself, referenced by vcs-pkg.org

Aeolus Project is a Red Hat sponsored project released under Apache License. It's purpose is to help people to have their own solution to manage and create cloud system hybrid and then run their instances on their own in-house infrastructure (VMware vSphere, RHEV, IBM's Smart Business Cloud, Eucalyptus) and also copy/run/manage their instances in multiple public cloud places (Amazon EC2, Rackspace, GOGrid,etc)

Aeolus does all of the image conversion/transfer/etc automatically, handling everything properly. Aeolus is a single, consistent set of tools to build and manage organized groups of virtual machines across clouds.

The talk will cover a variety of topics including: * Measuring success - and the success rates of mentoring programs * Preventing mentor burn-out, recruiting new mentors * Roping them in - turning interns into community members * Recruiting for diversity (Women's Outreach Program case study) * Keeping momentum - how to avoid ghost-towns

Dovecot is primarily an IMAP server, but nowadays it could also be used as a core for many other things: Rapid development of a feature rich email client, easily trying out your own IMAP protocol replacement, creating an IMAP proxy with mail filtering capabilities, and so on. Most of this is possible due to a new "imapc" mail storage backend, which makes Dovecot act as an IMAP client.

Dovecot is a widely used open source IMAP/POP3 server. Its internal design is based around libraries, which aren't very IMAP-specific. This allows using the same libraries to implement any kind of email related products. This talk gives a quick overview about 3 rapidly developed product prototypes: 1. MH-like email client built entirely with shell scripts and doveadm tool. The client is capable of reading emails from any IMAP server, as well as having a local full text search index. 2. A server for XML-based "XMLMAP" email access protocol. This server was used by a friend of mine who wanted to create a prototype email client without bothering to learn the IMAP protocol. The best thing about it was that he could access his own mails from GMail by using the "imapc" backend, almost as if GMail itself had implemented XMLMAP. 3. An IMAP proxy that can modify the message body contents, such as transparently decrypting PGP encrypted mails.

This talk will detail the architecture the CompatibleOne open source collaborative project and will conclude with a live demonstration of what seems to be the first open source cloud broker. CompatibleOne develops interoperable middleware for the description and federation of heterogeneous clouds comprising resources provisioned by different vendors. The aim of CompatibleOne is break vendor-lock-in for developers and users by providing interoperability with most platforms. The project contributes to the cloud stack of the OW2 Open Source Cloudware initiative (OSCi).

Want to hack some nice graphics algorithms, or just fix the most annoying bug your MBA friends keep nagging you with for Impress? Here's the place to get directions & ideas for that, plus some war stories from 10+ years of Impress hacking.

At the moment it is hard to find out what kind of Qt apps have been developed in the community, for various devices eg. Nokia N9, MeeGo tablets or Mer/Nemo. This is a missed opportunity for everybody. However we have such a system already in place, that is Apps for MeeGo (apps.formeego.org). It has all of the basic pieces in place already, and has been developed with the same folks who brought as the Maemo extras. In this talk I present the current status of apps.formeego.org (with demo(s)), and ask the question: can we build one central "app store" for community Qt applications? What is in place already, and what needs to be done?

Mozilla IT has been managed for a too long time by paid-staff only. We are now moving toward opening it to the community, be as open as possible. This talk will be about how we're doing it, but it is also an opportunity to gather feedback and exchange with the OSS projects that have always been working that way.

In 2011 the London Java Community (LJC) stood for, and overwhelmingly won a seat in the open elections for a seat on the JCP Executive Committee (JCP EC), enough acronyms yet? We haven't even started! It's been a whirlwind trip so far with a great deal learned about politics, acronyms, the due diligence required on a JSR, flights to exotic places (Jersey City!?), wrangling over the wording of a sentence and of course launching some developer lead initiatives. There have of course been some great successes in moving Free Java forward such as the JSR-348 which is the start of reforming the JCP and JSRs towards a truly open and transparent model. This talk covers the good works done so far, some anecdotes of what it's like to work as a developer amongst a mix of technologists and bearucrats and what we think is left to be done.

What the audience will learn from the talk: An insight to how the JCP really works and the surprising fact that Oracle and the other large corporates are generally pushing for a Free Java. How can people help out with the project, what feedback are you looking for? We want people to start supporting the JCP again and working with it to change it for the better, JSR-348 has proven that steps can be taken although we recognize there is still a long way to go.

A quick analysis of the risks and benefits that copyright assignment can bring to the Free Software ecosystem. I'll take a qualitative look at the side-effects of assignment on the diversity of project participants, and the knock-on impact that decisions in this area can have on the economics of supporting Free Software development. Come and find out how you can avoid making a mess of your community for some rather dubiuous legal advantages.

In this presentation, we will take a look at the Étoilé progresses over the past year. We will summarize our work on both our core frameworks and GNUstep. We will also discuss the project status in a broader way, and what can be expected in 2012.

After reminding you what Banshee is and why you love it, we’ll go through some of the features that have been added recently, and give you a glimpse of what we’re working on these days. We’ll then look into the future and try to guess what it might bring to Banshee. We’ll also show you how can be part of that future, by contributing a patch, filling bugs or writing an extension. When you develop a major multi-platform desktop application that is used by millions of people, you sometimes have to do some crazy stuff. So we’ll share with you some of those things. Some of them will make you laugh, some of them will make you cry, but all of them qualify for at least one of the following adjectives : crazy, ridiculous, insane, unreasonable, awesome.

Early last year, the EFL port of WebKit was missing all the fun in executing over 20000 tests found in WebKit's repository. Required tools have been written, bugs were fixed, and features were implemented in 2011. Progress, important milestones and lessons learned will be shown in this talk.

In order to provide better stability and ensure that future developments won't break things without them getting noticed, testing are an important part of software engineering. The WebKit project contains in its repository more than 20000 tests, scattered among different categories; most common ports (Mac, Qt, GTK+, the various Chromium ports) were performing these tests regularly, but the EFL port was missing all the fun. Tools were written and integrated in WebKit's testing drivers and after 6 months of hard work, we were able to pass 99% of these tests (excluding ones that are platform-specific and the ones that tests unimplemented features). In this talk, one of the developers will talk about the progress obtained while writing these tools, important milestones, and lessons learned.

Come and join us for the release of the Open Advice book. Open Advice is a collaboration of people from many different Free Software projects answering one question: What's one key thing you would have liked to know when you started contributing. We will give a short tour of the book and talk about some of the lessons learned from taking a large-scale book project from idea to publishing.

Showing new concepts for in-build tests and subsequenttests and how these concepts make automated testing easier and more reliable.

When a company authors free software under the GNU GPL, it is likely that it will discover license violations. Non profit like FSF or Software Freedom Conservancy will try to resolve such violations amicably, because their mission is to further Free Software. They will only go to court as a last resort, if the infringer refuses to comply with the licenses and keeps distributing the software. The primary goal of a company is to generate profit, it will therefore take advantage of violations to this end. For instance, part of the former MySQL AB company business model was to threaten infringers and require that they buy a proprietary license to be redeemed. However, most of the infringements are honest mistakes and such methods are not in the best interest of the Free Software community. They are even counter productive for the company who makes short term profits but eventually scare their customers away.

The buddycloud codebase provides an XMPP-based platform for federated social networking. In this talk, Simon Tennant will introduce buddycloud and explore the intersection of XMPP and HTTP.

In 2011 we learned that Certificate Authorities get hacked. What does this mean for the security of https and SSL/TLS? This talk covers the proposed solutions, why we aren't using any of them (yet), and how you can help.

Gnuk is software implementation of a USB token for GNU Privacy Guard. Gnuk supports OpenPGP card protocol version 2, and it runs on STM32F103 processor. Gnuk supports RSA 2048-bit key and it takes a second and a half for computation of digital signing. Gnuk Token is useful for GnuPG users and Debian developers. The talk explains current status of Gnuk and its future, supported boards, and how to use Gnuk with GnuPG and OpenSSH.

This talk is about the Linux open-source driver for nVidia GPUs (desktop and laptop). It will start by a recap of the history of this open source driver. The talk will then continues by detailing the current (and future) state of the following components: - DRM + ddx: Modesetting & 2D - Mesa: 3D - Power Management Some demonstrations will also be performed such as video decoding and power management. Finally, this talk will also allow you to interact with many Nouveau developers and ask your questions directly.

What can you do with your collection of sheet music, when all you have is paper or plain scans? You surely may feel frustrated if you are not ready for tedious sessions of manual typing. Here, *O*ptical *M*usic *R*ecognition comes to the rescue. It transcribes sheet music images to MusicXML symbolic format. Doing so, music content gets really "usable", since it can now easily be played, printed, transposed, re-published, analyzed, searched, etc.

*OMR* is difficult for a good reason: while text uses only horizontal lines, music combines the complexity of both vertical and horizontal directions. Today, there are just a few commercial OMRs available, and only one open-source product under heavy development activity: *Audiveris*. Audiveris is a Java application, using a neural network as its cornerstone. Collaboration is welcome on the most notable foreseen developments: - Smart coupling with MuseScore (Audiveris for the automatic OMR part, MuseScore for the interactive edition part), - Integration with Tesseract OCR V3, - Providing a web-based "OMR as a service", - Automated evaluation of transcription results, - Supporting microedition features to enable crowd-sourcing approaches.

PostgreSQL's extensibility is well known. Most people have heard of user types, user operators, the new extension capability, and such. But few know about hooks in PostgreSQL. This talk will cover all kinds of hooks available in PostgreSQL, and will show some tools using them already.

Start an instance on an internal cloud, then with the same code start another on EC2 or Rackspace. Deltacloud protects your apps from cloud API changes and incompatibilities, so you can concentrate on managing cloud instances the way you want. Deltacloud API prosper from natural open-source evolution and use community driven API design instead of vendor enforced one.

An introduction for creating Debian packages. The lecture is meant for people who want to package for Debian (or any Debian based distribution) with no prior experience or people during their first steps in packaging.

One common complaint you hear a lot about enterprise Java development is that it is quite a burden to get started. For a newbie, it takes a lot of knowledge and effort to even put the simplest JSF application to work. A second element that bothers a lot of people is that it is very difficult to verify that your enterprise components actually do what they are supposed to do. Even for seasoned enterprise developers integration testing can be a huge challenge. Luckily two recent additions to the JBoss toolset come to the rescue. Arquillian is a container-oriented testing framework built on TestNG and JUnit. It takes down the barrier of bootstrapping the necessary infrastructure when trying to perform integration tests. It lets you test your components in their real target runtime environment using real enterprise services. Secondly, JBoss Forge is an incremental enhancement tool that lets you take an existing Java project and safely add in new functionality. Whether you want to set up JSF, use persistence or enable integration testing with Arquillian, it all becomes a real breeze. Attend this session to learn how to take advantage of both these tools. You will see how they can be used to rapidly create, test and deploy enterprise Java applications. I will also show how they can be extended to put them even to greater use. They truly will turn out to be the missing links you have been looking for in enterprise Java Development.

Ref : https://docs.jboss.org/author/display/FORGE/Home Ref : http://www.jboss.org/arquillian

Maliit is an open source project for enabling first-class text input solutions for mobile devices. The project aims to provides a reference solution for easy integration, and a framework that others can build upon. It also strives to work closely with the wider community to improve mobile text input on open platforms. Current examples include its use in MeeGo, Nemo Mobile and Maemo Fremantle, the integration in Qt Components and Libmeegotouch, and improvements made to Qt and GTK+ input method interfaces.

Reviews of mobile devices most often include one or several sections about text input, and how well it works (or not). On-screen keyboard, language support, copy-paste and selection handling, error correction and word prediction, are all fundamental to a good end-user experience. The talk aims to highlight the importance of, and challenges in implementing, modern mobile text input methods on open mobile platforms. It also serves to encourage cross-project collaboration to overcome these challenges and explains how Maliit can provide a solid foundation for this collaboration. Maliit homepage: http://www.maliit.org

yaSSL made some great progress in the past year with the CyaSSL embedded SSL library. As such, this talk will provide an overview of technical and community progress in the last year and news on the current state of yaSSL. Details on what's new will include the addition of new cipher suites and cipher modes, better portability, new ports to software projects and operating systems, and community involvement.

This presentation will be delivered in two sections, first an introduction to the OpenRISC project by Julius Baxter, followed by a look at embedded hardware development with Open Source IP cores using the OpenRISC platform and the IP available on OpenCores.org with Olof Kindgren. The OpenRISC Project: This project is aimed at developing embedded RISC microprocessor architectures and open source RTL implementations. Since its beginning in 1999, the project has attracted anyone interested in CPU development and covers everything from ISA definition to RTL description writing and testing to simulator, tool chain and operating system porting. The presentation will cover the motivation, recent progress and future plans of the project. Open Source Embedded Hardware Development: Most Open Source embedded developers end their quest for a fully Open Source system when they get the data sheets. For the FPGA/ASIC developers at OpenCores, this is where the fun part begins. Instead of relying on the kindness of the chip manufacturers to deliver the desired SoC functionality, Open Source hardware developers simply design their own with the standard peripherals and custom hardware acceleration that of choice. This requires Open Source IP cores and a framework to put it all together. This presentation will contain an introduction to some of the benefits of open source hardware and an overview of OpenCores. The main focus will be on how to use the OpenRISC Reference Platform System on Chip (ORPSoC) to build a custom SoC, which will be demonstrated on the OpenRISC FPGA development board.

OS Lovelace: a distributed operating system in Ada, or how to have fun with both Ada and Operating System Development at the same time.

OS Lovelace already implements the basics of system programming and Ada run-time: interrupts (x86 and ARM), virtual memory management (x86 and ARM), elf module loading (x86 and ARM), context switching (x86), Ada exception in kernel (x86), Ada tasking in kernel (x86), Object Oriented programming in kernel (x86). The final proposed architecture for a real OS based on these trial developments will also be presented and so the method to obtain a distributed OS that support Ada Annex E natively.

Being a part of a number of large Free Software projects over the last years has been a wonderful time in so many ways. But over those years I have also gotten to know another side of Free Software: trolls, drama and gossip. Let me take you down the rabbit hole and show you where it comes from, what you can do about it and why it's sometimes even useful.

1. An overview of the problem of dealing with multiple server processes on multiple hosts and sites. How to provide fault tolerance and how to scale up without losing control. 2. A discussion of the use of the basic technologies such as Distributed Objects and property lists etc to implement these systems. 3. Control ... how we start/stop server processes, prevent duplication of processes, support automated restart, and query the state of processes. 4. Configuration ... how we provide specific configuration to each process under central control, yet allow those servers to operate independently. 5. Logging/Alarming ... how we provide and manage simple and consistent audit/debug logging facilities for server processes, and how we integrate with SNMP.

Broadcast has generally been the realm of expensive hardware and software and in the main quite objectionable to the use of FOSS. This presentation will talk about the challenges with developing and deploying FOSS in the broadcast environment, using the Open Broadcast Encoder as the main example.

This presentation will go into the technical, social and legal challenges of using FOSS in broadcasting; an industry viewed as highly sceptical of using FOSS directly. Nonetheless, the industry has passionate and dedicated individuals developing and slowly deploying FOSS. This presentation will use the development and deployment of the Open Broadcast Encoder, a FOSS application intended to replace expensive hardware encoders with commodity software as an example of FOSS can be incorporated into an industry not used to it.

The DMTF CIMI specification describes the model and protocol for management interactions between a cloud Infrastructure as a Service (IaaS) provider and the consumers of an IaaS service. The basic entities of IaaS (machines, storage, and networks) are modeled with the goal of providing consumer management access to an implementation of IaaS and facilitating portability between cloud implementations that support the specification. This talk will introduce the current work-in-progress CIMI specification and the initial implementation of that spec. as part of the Apache Deltacloud project.

Deltacloud exposes the CIMI API to HTTP clients and then facilitates management of IaaS resources across a number of heterogeneous cloud providers, even when those providers are non-conformant with respect to the CIMI specification. The DMTF Cloud Management Working Group is a collaboration between a number of prominent participants, including Red Hat, VMware Inc., Oracle, IBM, Microsoft Corporation, Huawei, Fujitsu, Dell, Telefonica, Telecom Italia, France Telecom Group and others.

Why Webfinger is so important, why BrowserId is so important, and how to combine the two.

The federated social web needs to be a tool-agnostic web. A user should be able to interact with other users, regardless of whether the other user is using xmpp-based tools, or OStatus-based tools, even SMTP, and maybe even SMS. But there is one central corner stone of socializing: user addresses. These can be email addresses, Jabber ID's, or webfinger account URIs. In this talk I'll discuss some of the challenges of enabling people to own their user address. In particular, I will discuss our experiences in both the LibreDocs project and the Opentabs project, about why Webfinger is so important, why BrowserId is so important, and how to combine the two.

By now, it's become well understood that Java is far from dead, and that rumors of its demise have been greatly exaggerated. The language once written off maintains its truly unique role as the power behind the legacy enterprise applications as well as the foundation for some of the biggest and most influential next generation companies on the web. What is less clear, however, is the future of Java the language versus Java the platform. JVM based languages are proliferating wildly: Scala, Clojure and its brethren are household names, and even established specialized languages like R are being ported to the JVM. What does this mean for the future of Java? Will they carry it forward into the future, or relegate it to the role of lower level component? We'll explore this question through a mix of quantitative data derived from sources like GitHub, HackerNews and StackOverflow, as well as qualitative research on technology developments and directions.

Here is the starter pack for the Writer hacker. Document model, layout and UI bits will be presented here to help you fix your pet bug or add cool new features.

Programming Arduinos made even easier (and more reliable).

An introduction to programming Arduinos and compatible ATMEL based devices in Ada. The talk will give a short explanation of how you can set up an Ada development environment for Arduinos, followed by some real-life code and devices, demonstrating some of the elegance you can get from using Ada for programming embedded systems.

Nemo Mobile is a linux distribution that is based on Mer Core and is using MeeGo Handset UX as its UX at the moment. Probably the easiest way is to think that the Nemo Mobile continues where MeeGo Community Edition (MeeGo CE) left off, with the main difference that it uses Mer as the core instead of MeeGo. In this talk the current status of the project is shown as well as the basics of how community can contribute to the project.

Thunderbird since version 3.0, what happened, how it happened and what's coming up.

Tumbler is a D-Bus service that generates thumbnails for various kinds of applications. Clients can pick from several schedulers and thumbnail flavors depending on their needs. Tumbler provides a plugin interface via which the list of supported file types can be extended. It already ships thumbnail plugins for videos, fonts, images, ODF documents, PDF/PS documents and RAW images. Thanks to its support for delegating thumbnail request to specialized third-party services, Tumbler can also be used with closed source thumbnail generators. Originally written for Xfce and its Thunar file manager, Tumbler was later integrated in MeeGo and is now used on the N9 as well. In this talk, I will explain the features, design, and usage of Tumbler as well as its current limitations. The ultimate goal is to make application and desktop developers aware of it and motivate them to adopt Tumbler in their software. The talk will include a live demonstration.

"IronPython is a member of the relatively new family of dynamic languages running on top of .Net platform, aimed to be a fully compatible implementation of the Python language, and released by Microsoft under the Apache licence, making it one hundred percent free. The Python platform itself has a big and vibrant community, and stands as one of the best and most used dynamic languages int the FOSS world. IronPython thus lets the .Net developers try this amazing language -being possible to smoothly invoke it from C# using the new dynamic features implemented as part of the 4.0 version-, and also lets the Python developers try the sweet bits behind the Mono and .Net platforms. I would be talking about the basics of IronPython, how it related to the standard implementation, how it interacts with C#, how to use the hosting API, and finally would take about a new IronPython addin for MonoDevelop I've been working in."

So you have your system set up to work perfectly. But moving to new machines, adding or changing configs etc is hard and takes way too much time. Thus, you hacked up a common CVS/SVN/Git/whatever repository and soft-link into $HOME. There is a better way and it's called vcsh.

I will demonstrate, in order: * the need for config management * how fake bare git repos work * what vcsh can do * show a demo * take questions if I have time

The Google Summer of Code (GSoC) has been a huge boon to the world of free and open-source software, and to Gentoo Linux in particular. In this talk, I'm going to share some of our successes, like how we manage 15–20 simultaneous internships and how we recruit a very large proportion of our students to continue as Gentoo developers.

Testing is an important task. But testing daily development-snapshots of a Linux-distribution would mean testing the same things every day, which would be pretty tiresome to testers. Yet, no one likes to break his system with untested code. This presentation will be about my solution to this problem, using automated testing with KVM or VirtualBox for openQA.openSUSE.org to guarantee some minimum quality. This will show some unique features like audio-testing, GUI-testing, and support for multiple distributions like Debian, Archlinux and Fedora. It will also have installation videos which are cool, fun and useful.

Implementation of PubSub, Service Discovery and User Location on top the Dutch Railways API.

Dutch Railways has opened up an API to their presentation layer. The API hooks into the back office and contains similar data as can be found on stations and their website. The system is pull based, and has a limitation of 40k request per unique API key, the format: XML. The openOV project removed the requirement for the API key by acting as open proxy, caching request and offering a PubSub allowing subscriptions to specific stations. Upon changes any subscriber gets informed, in realtime. Additional views in virtual nodes were made to retrieve data of a single train passing by stations. Some commercial partners popped up such as doing BOSH, to our service.

Mutability Detector is a lightweight static analysis tool for Java which allows you to unit test for immutability. Using immutable objects is regarded as improving readability of your Java code, and greatly simplifying multithreaded code. However, without language support, it's all to easy to render classes mutable, and introduce the potential for subtle, hard to detect bugs. Mutability Detector gives developers a way to write immutable classes, and help keep them immutable. Mutability Detector uses and depends on several free, open-source Java libraries, such as Objectweb ASM. Also, being able to look at the source of the JDK, has greatly helped in improving the analysis. The audience will learn of a simple little utility that may just help them in their day-to-day development of Java. People can help out in the usual FLOSS way - using it, reporting bugs, giving feedback (especially the ways in which I suck).

While everything is pretty much said and done on the x86 graphics front, and all the players have taken their respective positions and stick by it (despite ones best efforts), nothing has been done for the ARM world, even with the massive market penetration the linux and ARM combination currently has. The Mali is ARM's own GPU that is rapidly gaining traction. The most popular high end android smartphone so far is Samsung's Galaxy S2. The Mali-400 present in the Exynos SoC of the Galaxy S2 has been leader of the benchmarks for quite a bit. Besides the exynos, Mali is present in a rapidly growing number of SoCs, including telechips, allwinner, amlogic, realtek, VIA, ... The OpenGLES2.0 capable (and thus with separate vertex and fragment shaders) Mali is a highly clean design, and, of all the possible ARM GPUs, the perfect candidate for a free software driver. This talk will explain the rationale behind this project, the methodology used, the current status and the future direction. At the end, the current functionality (which is rapidly growing) will be demoed on both Mali-200 and Mali-400 based hardware. It will kick off a new era for free software graphics driver development.

In today's cloudy world of highly scalable applications, the database is increasingly the common culprit for most performance and scalability bottlenecks. NoSQL is often touted as the solution to your data storage woes, but data grids are a very viable alternative as well, providing both a performance boost to those using relational databases in the form of a distributed cache, but also as a primary key/value store. However, open source is crucial too since such systems often comprise of lots of cheap commodity-hardware nodes. Proprietary solutions based on per-CPU licensing models may scale in terms of transactions per second, but fail to scale financially. And this is where Infinispan comes in: the open source in-memory data grid for the JVM. In this talk, Infinispan founder and project lead Manik Surtani will discuss the role of in-memory data grids in the Java ecosystem, in relation to cloud, PaaS and enterprise software. Overlaps with NoSQL will also be discussed, as well as an update on JSR 107 and JSR 347, two JSRs that affect distributed caching and data grids.

Ref : http://www.jboss.org/infinispan

This presentation explains and demonstrates how Ada is effectively used to control a Segway-like self-balancing robot.

LEGO MINDSTORMS are affordable and attractive robotics kits that can be used as teaching material, or as funny and interesting hobby. We have used this kit to design a Segway-like robot, where the control system is written in Ada and built with the GNAT compiler. The concurrency and real-time capabilities of the Ada Ravenscar profile are used to implement the dynamic interaction with the physical environment, respecting very stringent timing constraints.

This short talk will address the following questions, to inspire discussion and contemplation about how we frame descriptions of the state of licensing in free software. * Numbers are increasingly being cited to show that the use of copyleft licenses, specifically the GPL, is declining. What do these numbers actually show, who is propagating them, and why? What do or might other numbers show? * Is the "percentage of free software projects which use copyleft licenses" a useful way to judge the success of copyleft? Does an increase in the percentage of projects using non-copyleft permissive licenses indicate a failure of copyleft? * As a small related case study, what role have the licensing terms of popular mobile application stores played in this debate, and how have those terms changed the frame of the discussion?

In this talk Rob will introduce the Mozilla Labs Apps project and the related technologies that are helping it happen. The aim of this project is to produce an apps eco-system on the Web that uses open technologies and gives developers and users the freedom to sell and use apps in the way they want. Aside from the conceptual issues that this project tackles, Rob will also cover some of the JavaScript APIs that are being worked on to provide the necessary functionality for apps. It is these APIs that allow developers to create an immersive experience within their apps that they wouldn't have been able to achieve in the browser until now.

PostgreSQL offers powerful means to enforce access and security policy on databases and their contents. This talk presents how to manage users and theirs rights from the basics to SE-PostgreSQL.

Introduction to QtonPi project, Goals, where we're, Where we would like to go & how to create, contribute, collaborate in the QtonPi project + demo

I've been moving the site operations model of the Wikimedia infrastructure from being a closed, mainly staff-only, model to an open to all model of contributions. I'm treating operations like an open source project, using Puppet, OpenStack and Git. The bottleneck of the operations team is greatly lessened, allowing volunteer contributions to be accepted and implemented much faster. In this presentation, I'll describe the architecture of the Wikimedia Labs project, and how we are utilizing it to allow anyone to push changes from ideas to production. I'll also describe how this same model can apply to other open source projects, and also how it could apply more generally in private cloud implementations.

In a highly connected world like ours is trust one of the most important assets. But what if the root to trust is not trustworthy? 2011 was the year where one Certificate Authority (CA) after the other came to fall. The cases of the Dutch DigiNotar and the Malaysian DigiCert are the best know. The system of commercial CAs depends on a wrong understanding of liability and trust. CAcert's web of trust tries to overcomes the liability issues by trusting a group of trusted people wherein each individual is liable for its own action. This talk enlightens why most commercial CAs are not trustworthy by default, what we can learn from 2011's cases, what makes CAcert different, why CAcert is not in the browsers by default and what we do to make it happen.

The talk is about operating system virtualization technology known as OpenVZ. This is an effective way of partitioning a Linux machine into multiple isolated Linux containers. All containers are running on top of one single Linux kernel, which results in excellent density, performance and manageability. The talk gives an overall description of OpenVZ building blocks, such as namespaces, cgroups and various resource controllers. A few features, notably live migration and virtual swap, are described in greater details. Results of some performance measurements against VMware, Xen and KVM are given. Finally, we will provide a status update on merging bits and pieces of OpenVZ kernel to upstream Linux kernel, and share our plans for the future. The talk is suitable for general audience, but will be of most interest to people interested in Linux kernel, resource management, virtualization, and cloud computing.

The talk is about operating system virtualization technology known as OpenVZ. This is an effective way of partitioning a Linux machine into multiple isolated Linux containers. All containers are running on top of one single Linux kernel, which results in excellent density, performance and manageability. The talk gives an overall description of OpenVZ building blocks, such as namespaces, cgroups and various resource controllers. A few features, notably live migration and virtual swap, are described in greater details. Results of some performance measurements against VMware, Xen and KVM are given. Finally, we will provide a status update on merging bits and pieces of OpenVZ kernel to upstream Linux kernel, and share our plans for the future. The talk is suitable for general audience, but will be of most interest to people interested in Linux kernel, resource management, virtualization, and cloud computing.

Hear how LibreOffice is tackling our users demands both for an 'app', a web office suite, and a traditional fat client, and how we have fun while improving the software.

As the world moves simultaneously either to the cloud or towards 'apps' - come hear how LibreOffice is tackling our users' needs in both of these (apparently conflicting) directions with the same code-base. See a demo of the LibreOffice On-Line prototypem, grasp the technologies, understand the benefits and problems of this model of web provision, and hear how you can play with / adapt gtk+ / broadway to your application. Hear about our handset / tablet developments, and our ongoing work to get smaller and faster. See how almost all the work we do for these products helps the normal fat-client office experience too. Finally, of course some degree of catch up with the progress of LibreOffice as a code-base and community as we ship our version 3.5 will be presented, along with pointers for how to get involved in development.

Wouldn't it be great if our phones, tablets, laptops and other mobile gadgets could use the same IP (v4 and/or v6) address regardless of which network they are connected to? And all that without a fixed tunnel causing path stretch, while offering some advanced traffic management features? This talk will present the LISPmob project, which implements a network layer mobility solution based on the Locator/ID Separation Protocol.

LISP stands for not just the programming language, but for the Locator/ID Separation Protocol as well, which is a soon-to-be-finalized IETF standard. LISP can be used to improve network layer mobility, by assigning a static Endpoint IDentifier (EID) to hosts, which are mapped to a Routing LOCator (RLOC) identifying the network point of attachment. Both EIDs and RLOCs are IP addresses. Transport layer connections use EIDs, while packets are traveling in dynamic point-to-point tunnels using RLOCs for encapsulation between hosts, thus avoiding path stretch. The LISP Mobile Node specification enables maintaining the same IP address regardless of network attachment point, and address family combination. For example, a device can use an IPv4 address on an IPv4-only, IPv6-only, or dual stack network. Since a roaming event does not change the IP address used by transport layer, ongoing connections (such as a SIP call) are maintained. Additionally, nodes with several available interfaces can define active-backup, or active-active load balanced incoming traffic policies. The LISPmob Project is an implementation of the above specification for Linux, consisting of two kernel modules and a user space daemon.

Mobile text input requires easy copy'n'paste interaction, reliable cursor positioning and the ability to edit (or fix) previously written text. For Asian markets, computer-assisted input of composed characters is of paramount importance. A virtual keyboard alone cannot solve that. For input methods to work, sophisticated platform and toolkit integration is required. The current general-purpose APIs that come with their respective input method modules in UI toolkits such as GTK+ and Qt are not sufficiently equipped for these tasks. Although the situation within the toolkits is slowly improving, Maliit - a flexible and cross-platform input method framework - can further narrow this functionality gap. This talk will analyze problems of mobile text input and show how they were solved on Nokia's N9.

to be written

TDF provides not only a stable and reliable software to its users, but also a stable and reliable infrastructure for its community. Contrary to what we had before, most of the knowledge is now inside the community, giving a flexible and scalable solution that grows with the demands of the project. This talk gives an overview on the infrastructure that drives the LibreOffice community, including technical details on server administration and management.

Crossdesktop devroom group picture and mid-day break

The ZIO framework is a novel way to manage laboratory input/output. It handles both data and meta-data, and is designed for multi-MB-per second I/O in distributed systems.

ZIO is a framework for high-data-rate I/O. The basic I/O item is a block, made up of data samples and full meta-data information, so input can be consumed offline and output cam be prepared in advance. The main use cases are waveform generation and distributed oscilloscopes, over possibly hundreds of systems spread over several kilometers. Within ZIO, the buffer and the trigger are first-level objects, and both input and output have always been supported. Data flow is a pipeline made up of device, trigger and buffer; usually the buffer is connected to char devices, but in-kernel users have been written with minimal effort. Code is being developed at http://www.ohwr.org/projects/zio and is being submitted to the kernel.

A lot has been said about writing your first patch, but how about adding a new feature? * What's the impact that volunteer contributors can have in innovating the browser? * Who is going to work with you and what's your role as a developer? * What can you do to ensure the work you start will be completed? We'll talk about these topics using the Firefox Downloads Panel as a real-world example.

Motivations for real-time text in XMPP, the seamless addition of the feature, the protocol in XEP-0301, and its use.

The presentation describes the functionality of real-time text added to the XMPP environment by draft extension XEP-0301. By application to both sending and receiving XMPP clients, a more fluent conversation by text is achieved, where text is displayed at the far end at the rate it is typed by the transmitting party. This reduces stress and waiting time in intensive text communication situations. The extension can be seamlessly applied, so that if it is not supported by both ends, the functionality is as plain message based XMPP. Therefore introduction can be made gradually. In order to not overload servers and networks, the trasmission itervals can be kept long, and instead the real-time impression get recreated by a feature called "Natural Typing". Opportunities for interoperability with real-time text in other environments will be explained, and indications given for easy integration in other XMPP implementations. Demonstrations will be made of the RealJabber client, implementing the draft as an open source project, managed by the author of the XEP-0301 draft, Mark Rejhon. It is with the experience, need and interest from people with communications related disabilities that this extension is developed, but it has apparent benefits for all.

Gentoo currently has 400+ natively packaged ruby packages for 5 different ruby implementations. We'd like to share some of the unique things we did to bring ruby code and applications to our users in a true Gentoo fashion.

Discussion of the possible decline of copyleft licensing.

During the past few years some have asserted that the use of copyleft licenses, particularly the GPL, is in decline among FLOSS projects. While the data that is said to support this contention may be suspect, it matches my own observations and experience. I examine why the GPL may really be experiencing some decline relative to noncopyleft licensing. Many factors are likely to have played a part, sometimes in contradictory or nonobvious ways, including the evolution of open source "business models", the nature of GPL enforcement and nonenforcement, the drafting of GPLv3 and its aftermath, changes in moral and legal authority surrounding the GPL, and general technological, cultural and economic developments affecting free software hackers. If it is real, the GPL's decline is a problematic development for free software culture. I propose ways in which the trajectory of relevance and influence of strong copyleft can be turned around.

SyncEvolution has been the main synchronization engine in Moblin, MeeGo (together with Buteo) and will also be used in Tizen. In addition there have been stable, regular upstream releases for desktop Linux since 2005. Ports to the N900 and N9 are available, using their native PIM storage. This talk will give an overview of the architecture and introduce the latest features: KDE support, CalDAV/CardDAV synchronization, and ActiveSync.

The slides can be viewed at http://syncevolution.org/blogs/pohly/2012/fosdem-2012 PIM storage and synchronization are important topics on mobile devices because of the central role that the data plays and the intermittent network connectivity - thus the need to keep local copies of important data and synchronize when online. One (but not the only) supported storage backend is Evolution Data Server. When Nokia left MeeGo, Intel reverted back to EDS as the main storage for PIM data in MeeGo and started to improve it. The initial round of improvements were aimed at minimizing overhead for sync and have been accepted by the upstream project. This talk summarizes these changes and outlines some further ideas.

FOSS distributions are increasingly over pressure to deliver stable releases including the most up to date upstream software. Time-based release strategies has exacerbated this problem putting even more pressure on QA teams. The recently concluded Mancoosi project has developed a number of tools to automatically analyse large packages collections for a range of problems, from installability checks to speculative analysis of software repositories. In this talk I'll present four command line tools to identify and correct potential problems as soon as possible during the release cycle.

In particular : * Debcheck: This tools helps to identify all broken packages within a repository and provides a detailed explanation of the problem. This can be used to prevent shipping releases that contain packages that cannot be installed because of missing or malformed dependencies. * Buildcheck: Given a Sources file and a set of binary repositories, this tool identifies those source packages that cannot be compiled because their build dependencies cannot be satisfied. * Outdated: This tool identifies those broken packages that need special attention because of outdated meta-data. * Challenged: This tool performs a speculative analysis of the repository to identify those packages that, if upgraded to a specific version, would break a large number of other packages in the repository. This tool would be particularly useful during the upgrade of a specific component to evaluate its impact on the software archive. Most of our tools support both rpm (version 4 and 5) and deb based distributions.

CacioCavallo is an award winning project sponsored by the OpenJDK porters group. The main project was about refactoring of the graphics stack of OpenJDK to allow of easy porting on various platform. It’s the abstract backend behind most ports and it has been used on field by commercial projects for companies in the embedded and automotive market. During the last year, two new projects have landed in the official Caciocavallo repositories: CacioWeb and Cacio Testing Framework. The first project allows for easy deployment even on platforms without any Java support (like Apple iPad) and makes extremely easy the deployment even without any Java plugin. CacioTest aims to make easy the testing of Graphics stack, providing a reliable, unobtrusive way to run UI and graphics related tests.

1. Talk covering a the history of MonoGame, where we are at and where we want to go. We will show some demos of things running on Mac, PC and iOS/Android devices. This will be presented by Dean Ellis, Kenneth Pouncey and Me. 2. Using advertising within iOS/Android. This will be presented by Dean Ellis & Me. 3. Networking within MonoGame. This will be presented by Dean Ellis, and Kenneth Pouncey.

The Wishbone bus is an open source hardware computer bus specification intended to let different logic blocks within an integrated circuit communicate with each other. This talk will introduce a set of memory mapped data structures that allow designers to describe their own logic blocks, thus allowing for the auto-discovery of devices on a Wishbone bus.

The Wishbone bus is an open source hardware computer bus intended to let different logic blocks within an integrated circuit communicate with each other. This talk will introduce a set of memory mapped data structures that allow designers to describe their own logic blocks. Thus, for compliant chip designs, the operating system can enumerate the Wishbone bus inside the integrated circuits and load the appropriate drivers, similar to PCI or USB. The proposed specification is already being used in a set of FPGA based cards being developed at the Open Hardware Repository. By defining a new bus type within the Linux kernel, the driver for each board can register as a Wishbone controller and benefit from automatic enumeration. The bus controller can use the information it retrieves to load or activate the appropriate set of drivers to manage either the whole board or the various peripherals that are attached to the internal Wishbone bus. Such a scheme greatly simplifies managing the variety of FPGA binary images, by allowing automatic division of the problem space. Even when a single driver is needed for the whole device-set within the internal bus, a standardized identification mechanism reliefs system administrators from manually matching FPGA images and software drivers.

Calc has been described by some as a cross between a programming language and a brick factory; come and see how it fits together and how you can get stuck into torturing it into doing what you really wanted all along.

OpenEmbedded and the Yocto Project have recently changed their structure to collaborate around a common base: OpenEmbedded-Core, with additional layers being developed to be used on top. Moving to a multi-layer structure presents both organisational advantages and challenges. This presentation will cover both technical and community aspects and will include recent developments in Yocto Project / OpenEmbedded structure, the current layer landscape, best practices for developing new layers and growing existing ones, and layer tooling enhancements developed as part of the Yocto Project that will benefit the entire OE community, as well as future plans along those lines.

In this talk we will explain how some common attacks against vulnerable software work and will explain how the security measures used by the Gentoo Hardened project act against them along with the drawbacks they impose.

This talk will give a quick intro into the RHQ systems management and monitoring system and then show recent developments like "Dritf", the detection of changes of files and configurations, the REST api for easy access to collected data from other programming languages. Last but not least I want to point out some possible future development - especially in the area of alerting.

Ref : http://www.jboss.org/jopr

When asked by a client to help them setting up a PostgreSQL cluster with NFS-based storage, my first gut reaction was: don't. But as it turns out, this is not such an unholy combination; as long as you keep in mind the effects different settings have on both the NFS client and NFS server and the expections PostgreSQL has regarding file operations, one can get away with it.

The Xen Cloud Platform (XCP) is an open source virtualization platform based on the Xen hypervisor. XCP isn't a server application which you install alongside of Xen, but rather an "embedded" appliance, which manages your host. While this gives XCP developers the ability to provide a tightly controlled, well integrated system, it makes it more difficult for FOSS developers to use and modify our software. To correct this, we have recently ported the XCP toolstack to run on Debian; it is currently in Debian unstable and will be in the next release of Ubuntu. In this presentation, we would like to demonstrate the XCP toolstack running on Ubuntu. We will show how easy it is to use the toolstack to create and manage virtual machines, and how you can use XCP and XenServer management tools with the XCP toolstack on Ubuntu. We will also demo our software running OpenStack.

Our "Soft Emergency Call System" solves two problems: event aggregation and event visualization.

We designed a "Soft Emergency Call System" to deploy in local government to provide care in an aging society. In the design process we had 2 issues ("Event Aggregation" and "Event Visualization"). We describe two ideas to solve those issues, and introduce the system's implementation and development environment.

Version 1.12 of the X server is scheduled to be released in early March, shortly after FOSDEM occurs. The talk will cover what has changed since 1.11, including multi-touch support, and a raft of code cleanups to try and bring the server out of the last century. Beyond 1.12, this presentation will outline further work planned for the Linux desktop. How X and Wayland will work together, the work remaining to support OpenGL 3.0 and beyond within the X environment and further plans to streamline and modernize the code base.

Every Detail Matters is a new initiative that aims to focus attention on improving specific areas of the GNOME 3 user experience. It also aims to provide an easy way for people to make a valuable contribution to GNOME by identifying development tasks that would make a real difference. The initiative involves designers working closely with both new and experienced developers to refine GNOME 3. We are working towards delivering a major and tangible improvement to the next release, version 3.4. In this talk I will describe the key features of Every Detail Matters, demo some of the progress that has been made thanks to the initiative, and will show how you can participate to make GNOME 3 better than ever.

"Apple drops GPL apps" was a headline in the Linux User & Developer Magazine in 2011. Later Windows followed the example of Apple. So does this mean GPL licensed apps can't go mobile? Luckily, it's not that dramatic. This talk will share the first hand experience of the challenges and opportunities of releasing GPL based apps in the Apple app store.

I will describe the technical and social aspects of documenting the Open Web, trying to extract common points applying to any open documentation project. I will present the different kinds of articles expected by the different users, their respective constraints and the solution we chose. I will talk about the accuracy problem and the communication processes. Finally I will speak about the challenges that the Open Web documentation is facing, like contributor motivation, the mobile Internet or new technological opportunities to improve the user experience.

Discover how Ada catches up with web application development.

Ada on Rails is a bleeding edge Ada tooled framework environment that enables web applications development. The goal of Ada on Rails is to efficiently use all the strength of the Ada based technologies in web applications, while being: Rapid Application Development compatible; agile friendly; safe and secure; ready for formal method through SPARK Ada; low code, memory and CPU footprint; range from bareboard to large scaled distributed SOA applications.

How to find your way through the complexities of LibreOffice, or any other large project; or "Find the needle in the haystack effectively", hear about our sexy new python debugging tools and techniques.

With iOS 5 and OS X 10.7, Apple introduced a number of new Objective-C features. With the release of version 1.6 of the GNUstep Objective-C runtime and version 3.0 of clang these are now all available to GNUstep developers. The new features include better data hiding, automatic reference counting, and a number of other features. This talk will cover these features, as well as some of the extensions beyond Apple's version and the improvements in Objective-C performance since FOSDEM last year.

The people who believe in free software and open education have a lot in common, but few shared projects. Wikiotics has run for three years as a one such hybrid project and in the process spent a lot of time talking about education at free software conferences and about free software at education ones. If you have ever wondered why there aren't more projects like Wikipedia out there, come hear about some of the difficulties and opportunities for Foss/Edu collaboration.

Openness, sharing, collaboration, and everyone's right to use, for any purpose. With these shared values, the partnership between free software and education should be natural, yet too often these communities operate without ever interacting. At Wikiotics, a language instruction project built from our own free software, we have faced puzzled looks at every turn. As the only education project at free software conferences and the only free software project at education ones, we have talked to many people from both communities about our common values and learned a lot about the barriers to working together and the incredible potential for social change when we collaborate. Come hear a little bit about our strategies for overcoming them.

We are recently witnesses of continuous performance improvements both in hardware and software worlds. However for systems with millions requests and users, performance is still very important. One of not that obvious performance optimizations is Garbage Collection selection and tuning. Garbage Collectors save us a lot of time and shield us from low level memory problems. However to take full advantage of Garbage Collection, we need to make the exploration process easy. Visualizing the Garbage Collection techniques (visualizing events, understanding memory abstraction and fragmentation, history observation) is critical for mentioned performance tuning, lowering the memory allocation, consumption and GC pauses. This talk will introduce Garbage Collection in nutshell, but especially abstractions and terms defined in GCSpy project and summarize the porting process of GCSpy to NetBeans platform. We will look at advantages of NetBeans platform, summarize faced challenges and current status of the project and further ideas. I am looking for ideas to improve the GC visualization even more, other VM support (at least partial) and architecture overview.

Snapper is a new tool introduced first in openSUSE 12.1 to manage btrfs snapshots. It has received great attention from the press. In this talk we will give an overview of btrfs capabilities and how snapper integrates btrfs snapshots into the system for easy use by the user. We will explain how other software can use the power of snapper. Finally we will give an outlook of future development.

The database component is one of the pieces most in need of love in LibreOffice. Come and hear how one noble, lone hacker has made a huge difference to this component, and how you can get stuck into improving this key piece of the suite.

A brief overview of, first, what CSS features have been implemented recently in Firefox, second, what new CSS features are in development in the CSS Working Group at W3C, how far along they are, and when they're likely to come to browsers.

Ada enters into the peer-to-peer world.

Peer-to-peer technologies have became commons nowadays. Initially developed for file sharing, the peer-to-peer approach is moving into the more challenging field of streaming. PPETP is a peer-to-peer streaming protocol, developed at the University of Udine, initially designed for streaming live material to large user communities and evolved with time into an efficient, generic overlay multicast protocol with many built-in features (e.g., signatures, NAT traversal, robustness, priority classes) that make it practical. After few years of development, adjustments and optimizations, PPETP is finally getting ready for its first public release. Its official specs are published as an Internet Draft, while its reference implementation is an open source Ada library (~1.5 Mbyte of source code) designed to be used, in the most common cases, with an interface similar to the well-known BSD socket interface. In this talk, after a brief overview of the most interesting characteristics of PPETP, we will discuss some of the most challenging aspects in its implementation and how Ada was instrumental to solve them.

Getting to the point of having a working, low-resource DLNA-ready implementation is a hard task. Fortunately there's an easy way out - Rygel. It is a modular and extensible solution to help you out of that dilemma with minimum effort. Rygel started its life for GNOME Mobile and was the designated UPnP/DLNA stack for Maemo Freemantle and MeeGo/Harmattan. It is supposed to work out-of-the box with no setup required, operating nicely with all kinds of quirky devices.

A talk about Jingle, its variants, its features, its NAT traversal, how it compares to SIP and everything you can do with it.

In this presentation we will use Orchestra (including juju) to deploy an openstack powered cloud. We will dive into the components and how they fit together to orchestrate an openstack cloud deployment.

So-called "app stores" are becoming a popular means of distributing software, particularly for mobile devices. However, the rise of app stores has been accompanied by tensions with free software/open source legal norms. Companies controlling official app distribution channels for their platforms typically place restrictive terms on both users and developers in ways that may be difficult or impossible to harmonize with requirements and expectations around FLOSS licensing. Moreover, there is a perception that noncompliance with FLOSS licenses is prevalent in app store distribution. This panel will explore some of the problems arising out of the intersection between app stores and FLOSS, under EU as well as US law, and will discuss possible solutions.

Telepathy is an instant messaging, Voice over IP and videoconferencing cross-desktop framework with backends for today's most popular protocols. Its modular and flexible architecture built around D-Bus enables developers to easily create communications applications with interchangeable components. A small team inside the KDE community is working on Telepathy integration into KDE Workspaces. This talk should provide an insight into the current state of KDE-Telepathy development, its plans and possibilities.

The KDE Telepathy team aims to deliver an Instant Messaging experience fully integrated into the workspace, built on top of Telepathy technologies. Thanks to the active upstream development of Telepathy itself (including protocol backends), the KDE Telepathy team can better focus on the user interfaces and their integration with Plasma Desktop. Both teams cooperate very closely and it is great example of upstream-downstream teams working together. This talk should briefly cover Telepathy architecture and its current usage "in the wild", then the talk will mainly focus on Telepathy in KDE Workspace and Applications - brief project history, overview of ready to use components, plans for the near and far future and examples of how to use Telepathy in existing network based applications.

Transifex is an open-source localization platform. It helps developers manage the localization process for their software. Especially in the open-source world, localizing the software is very important. This talk will explain briefly what localization is, what are the issues that arise and how Transifex can help projects manage the translation workflow.

Transifex is an open-source localization platform. It is already used by a lot of open-source projects, including fedora and meego, with great success. The talk will focus on explaining what localization is and why it is important. It will also describe how Transifex works and how it can help the developers integrate translations in their workflow and the translators to cooperate better to help with the translations.

XWT is a new cross platform GUI toolkit for Mono and .NET, which is based on the idea of building an abstract widget library on top of platform-specific native widgets. This toolkit is still in a very early development stage, but there are already backends for GTK+, MonoMac and some initial work on WPF. The talk will explain the goals of the project and some details about design principles and internal architecture.

Looking into the future of Ada, not just as a programming language but as a basis for building highly reliable software.

Ada is a language that is used for the construction of large critical programs, including safety-critical programs where an error can cost human lives. In looking into the future of Ada, we are doing more than just thinking about details of programming language design, we are really thinking about the whole issue of how to build reliable applications in a society which depends more and more on complex software. Ada is an interesting language precisely in that its development has been open from the start (it is one of the very few ISO standardized languages where you can get the ISO standard free, we insisted on that!) And the primary implementation of Ada these days is the GNAT system, which is 100% Free Software. The Chevy Volt automobile has over 10 million lines of embedded code, more than the 8 million lines aboard a Boeing 787. Many times a day we place our lives at the mercy of complex software. How can we be sure this software will not let us down and kill us? This is not just a theoretical question, patients have already died at the hands of incorrectly programmed medical devices, and although no one has died from a bug in commercial aviation, we have had some horrifying close calls. Things are going to get worse and worse if we don't figure out how to deal with this situation.

This will be a talk about the future of computing and how we can push networked solutions that are just as much under your own control as your desktop computer.

The OpenStack developers ecosystem consists of OpenStack core developers, but also upstream project developers and downstream distribution packagers, producers of compatible tools... In this town hall meeting, we will all gather for an informal workshop where we'll openly discuss issues and how we can solve them as a community. In particular, we'll have a panel discussion with packagers from various distributions, but we also expect themes like project policies, QA or governance to be addressed. Come and join us !

Virtualization presents a unique set both of challenges and opportunities. You'll find out what a good many of these are, and how to take advantage of the latter while avoiding the former as much as possible.

In this presentation, I will provide an overview of how big rewrite and redesign efforts have affected the development of the OpenWrt project. After showing two past examples of big structural changes, I will introduce the current effort to redesign large parts of the OpenWrt user space components. This redesign aims to bring some interesting approaches from the Desktop Linux world over to Embedded, without bringing along the amount of bloat that is usually associated with them.

Gentoo uses versioning in the package manager script format. EAPI is the contract between ebuilds (Gentoo's packaging scripts) and the package manager. The version currently in use is 4. This session is about looking over features in the pipeline for the next version and hopefully having a discussion on them and others. Traditionally multiple council members have attended FOSDEM so this is your chance to influence the technical direction of Gentoo package management.

This talk is centered on Elementary and Edje for nice applications. I will explain my experience with EFL and show some code with some results.

Discussion on issues of Free Software with Software Patents

Boot2Gecko (B2G) is a complete OS built on the open web platform. Every "app" from the lock screen to the phone dialer is a "web app", built with HTML/JS/CSS. Where we encounter gaps in the open web platform as compared to other phone OSes, we plug the gaps with new Web APIs, to be standardized by web standards bodies. If you know how to write a web page, you will be able to write phone apps. B2G is developed according to Mozilla's values: in the open, with source code always available, and on open standards. In this talk, we'll discuss the motivation for B2G and some of its implementation. And of course, there will be a demo!

The Growl Project, started in 2004, is the de facto open source notification framework for Mac OS X, and it's currently used by a wide range of applications, such as Firefox, Chrome, Adium, Skype, Dropbox etc. In this talk, we will present Growl, the various Growl Extras, and the GNTP protocol used to send and receive notifications locally or over the network.

We would like to present a brief history of Growl, as well the current state of the framework that handles notifications. We will also present the Growl Extras, applications developed by the Growl Team which use Growl to notify the user on various events (GrowlTunes, HardwareGrowler, GrowlSafari, Capster), and how easy it is to use the Growl framework to notify your users in your own applications. We will also discuss the GNTP protocol, which is used to send and receive Growl notifications locally or over the network. GNTP is platform-agnostic, and there are already GNTP-compatible Growl alternatives for Windows and Linux. Thanks to the variety of bindings, it is easy to send Growl notifications between computers and any GNTP-compatible device. Last but not least, we will briefly discuss the recent decision to use Apple's marketplace as a revenue stream in order to sustain the continued development of the growl project and the expansion of our efforts, without sacrificing our open source nature.

Architecture and use cases of Salut à Toi, a XMPP client with multi frontends (console ncurses-like, command line interface, desktop, web), with special focus on microblogging.

This talk aims to briefly present the Salut à Toi project and its goals. Salut à Toi is a XMPP client which focus on the whole XMPP stuff, not only instant messaging, and where many frontends use a common backend. The following points will be covered: - global overview of the project - why a multi-frontends client ? - the architecture/technologies used - quick presentation of some features - XMPP as a replacement of traditional e-mail network

LPSP stands for LibreOffice extension providing connection to SharePoint. This Java extension is a great solution for users needing SharePoint support right now and/or don't consider upgrading (yet) to newer SharePoint versions supporting CMIS. We'll also take a short time to explain about the CMIS connection and why it is a cool thing to hack on.

The jBPM workflow engine and the Drools rule engine and the help you extract your business logic in workflows and rules, so you don’t need to hard code it in Java. For example, suppose your application handles mortgage approval and you have a team of business experts at your disposal that can’t program. What happens if your business experts want to add a workflow action to send a mail upon each mortgage approval above 100 000 € with an applicant below age 30? How long does it take to hit production? Can the business experts easily read the changes before they hit production? With Guvnor and the jBPM designer, those business experts can write and edit the workflows and business rules themselves. They can verify them and put them in poduction.

The jBPM workflow engine and the Drools rule engine and the help you extract your business logic in workflows and rules, so you don’t need to hard code it in Java. For example, suppose your application handles mortgage approval and you have a team of business experts at your disposal that can’t program. What happens if your business experts want to add a workflow action to send a mail upon each mortgage approval above 100 000 € with an applicant below age 30? How long does it take to hit production? Can the business experts easily read the changes before they hit production? With Guvnor and the jBPM designer, those business experts can write and edit the workflows and business rules themselves. They can verify them and put them in production. Ref : http://www.jboss.org/jbpm Ref : http://www.jboss.org/guvnor

This talk will summarize the current status and recent progress made in Gallium3D and the Nouveau driver to support general purpose computing, in particular the OpenCL API. The main problems that had to be addressed and the ones left to solve in the current implementation will be put forward and discussed.

One area in which proprietary JDK releases have traditionally showed superiority over OpenJDK is in monitoring and instrumentation tools. We aim to overcome this shortcoming and even reverse the trend by introducing a new, scalable tool to the the ecosystem: Thermostat. During the last half year, we've been quietly coming up with a plan for how this tool should work, and we're now ready to share what we've come up with. By working with others in the open Java community, we believe that we can make the most useful, most comprehensive, and all around best application of its kind. In our presentation, we will describe our extensible model for collecting JVM and system monitoring data side by side. Attendees will learn about the features we have planned, see a short demo of what is already working, and hopefully be inspired to join us in in making this awesome tool a reality.

This talk will introduce ObjXMPP, a portable XMPP library written in Objective-C. Achievements made since this project was started at FOSDEM 2011, as well as some code examples will be presented.

QuantumSTEP is a technology study framework and application suite that is partially based on GNUstep. It aims at consequently using Objective-C on embedded and portable devices. This talk describes the latest additions to the frameworks: CoreLocation, MKMapKit, CoreWLAN, CoreTelephony and demonstrates how they work on the new GTA04 hardware.

At the [AppInstaller2011](http://distributions.freedesktop.org/wiki/Meetings/AppInstaller2011) meeting I started writing [Distromatch](http://www.enricozini.org/2011/debian/distromatch/) which is able to map binary package names across different distribution using a wide set of euristics. Distromatch has the potential of being a radical change in cross-distro cooperation, enabling exchange of package screenshots, categories, ratings, reviews and many other interesting kinds of metadata. Since distromatch has existed for almost a year and (afaik) so far none of this has happened, I am taking advantage of the cross-distro room to show how it works and discuss how to move on from here.

This lightning talk will be an overview of the important features of PMD 5.0, from which a beta should be release before then.Introducing briefly what PMD does (static code control and analysis) and how it does it (using XPath to query over Abstract Syntax Tree provided by pre-compilation), the talk will focus on the more important enhancement of this version: multi language support, mostly achieved by the great work of Ryan Gustavson between 2009 - 2010. With this features, PMD can be easily extend to support a large set of languages, including already XML based languages and ECMAScript (more commonly designated by the name JavaScript)

Creative Commons has since its launch in 2002 acknowledged free software as an inspiration, but in-depth communication and understanding across the "free culture" (and education, science, government...) and free software movements has been thin, resulting in missed opportunities (at least on the free culture side). Two developments make early 2012 an opportune and necessary time to address this. First, Creative Commons has kicked off a process which will eventually lead to the release of version 4.0 of various CC licenses, which ought incorporate the best wisdom about public licenses (most of which resides in the free software community) and not need to be versioned again for a decade. Additionally, among the issues under discussion for CC 4.0 licenses are ones of direct import to the free software community, including how DRM and license compatibility are addressed. Second, CC licenses have become fairly widely adopted as policy for public sector and publicly interested materials and funding, especially in education. Free software and even open standards are inadequately accounted for these developments, presenting a significant and unappreciated threat to the realization of public benefit from such -- a continuation of the tendency of free culture (with the exception of Wikimedia) being dependent on proprietary web silos. This talk will very briefly summarize the relevant history, describe the pertinent CC 4.0 licenses and policy issues, and hopefully provoke solutions and actions benefiting free software and free culture.

This talk will cover the basics of MonoMac and how the Mono runtime was integrated with the Objective-C runtime. Although MonoMac is actively being developed on OSX, there are efforts to make it run also out of the box with two open source Objective-C/AppKit Stacks.

Above all else, LibreOffice is a vast corpus of C++ source code of varying quality. Static analysis of that giant code base guarantees a constant stream of interesting findings. The talk will look at how plugin architectures of modern C++ compilers allow to tap that stream.

The Hotspot/OpenJDK Java agent capability and its associated java.lang.instrument API provide support for runtime bytecode transformation, either initially at class load time or, since JDK6, retrospectively after classes have been loaded and instantiated. This API has been adopted as a de facto standard by several other industrial strength JVMs. The uses of this API extend far beyond simple code instrumentation and suggest that more widespread adoption of the OpenJDK Java agent model and use of Java agents is highly desirable. Byteman is a Java agent program and suite of associated tools which supports tracing, monitoring and testing of Java applications via bytecode transformation. This has many advantages over conventional approaches, in particular being much more flexible and far less invasive. This talk will demonstrate Byteman in action showing you how to install and run it both standalone from the java command line and integrated with the JUnit and TestNG test frameworks driven from ant or maven. The examples progress from injecting simple debug trace to displaying a timing bug in a multi-threaded application. Along the way you should learn how Java agent programs work and how much freedom they have to manipulate the JVM runtime. I hope to encourage many of you to use Byteman and to contribute suggestions for new features. Also, maybe a few of you will be inspired to implement your own agent programs or to provide support for agents in other JVMs.

UI development usually consists in building software components that rely on a business data model. But business data models need to change frequently to adapt user requirement updates. This implies to adapt frequently the UI components. Nowadays, existing solutions provide a way to support these changes by providing code generation and data binding. But, these solutions are still slow. Then, the development cost increases rapidly if you have frequently requirement updates and/or many UI components. Wazaabi aims to reduce this cost by providing a solution based on models which doesn't require code generation. Based on Eclipse EMF, Wazaabi provides an open source framework that implements a dynamic declarative UI mechanism. The Wazaabi framework is directly based on the business data model and will evolve with it. This presentation aims to give a look inside this framework.

Wazaabi is an open source framework for declarative live UI-model. In this term two different concepts are included. * The declarative UI, means that Wazaabi enables the designer to describe the UI declaratively. * Model means that the declaration build an instance of a model of the GUI. A model is a conceptual representation of the UI. * Live model means that we do not generate code from the Model as it is usually the case with the MDA approach. In Wazaabi the UI is a running instance of the model and an engine is responsible for rendering the model in the target UI technology (SWT, SWING, JSF, etc.)

WebFWD ("Web Forward") [https://webfwd.org/] is Mozilla's Open Innovation program. We support Open Source projects which extend the Web; providing participants with mentorship from industry experts, access to the Mozilla global network, infrastructure and other world-class resources. This talk will give some more detail on what types of projects fit in the program, and how you can apply. Innovate with is and help move the Web Forward.

Ten quick reasons why LibreOffice is a great place to make your blow for Free Software, with some detail about how we make this a fun place for you to get involved.

This short talk is intended as the opening talk of the entire devroom. After a welcome greeting, I will briefly ponder about the motivation for meeting together and attempt a basic quantitative comparison of participating projects based on available project-metric data. The goal of this quick comparison is to illustrate some apparent similarities and differences between our projects, and to further support our common cause.

In one sentence: "The Spice project aims to provide a complete open source solution for interaction with virtualized desktop services". This talk will give an overview of: * What Spice is * How Spice works (globally) * What makes it better then using ie vnc to access a remote virtual machine * Future features

The purposes of this talk are: * To inform people about the Spice protocol and the Spice project * Get feedback for future versions * Hopefully get people to use Spice and maybe even become contributors

Rudder is a new open source tool in the configuration management domain. Its aim is not to reinvent the technical wheel, but to provide a new way to drive our infrastructure.

Specifically aimed at drift assessment, it addresses automation, ongoing verification and repairs, centralizing information and knowledge about your infrastructure, compliance reporting... thus helping to keep drift from nominal behavior low. Built upon a standard CFEngine architecture (and other open source components). This talk will show how Rudder's approach enables everyone in the IT department to benefit from the advantages of configuration management, without necessarily needing to learn a complex tool, or even get their hands dirty. We'll describe and demonstrate how this is possible, and dive into the technical architecture that makes it work. In a nutshell, clearly separated tasks permit technical experts to create configuration templates for the tools they know best, thus letting non-experts leverage this power via a modern web interface, such as: architects or security officers who implement policy, junior sysadmins who use and reuse such policies to setup services, and pretty much anyone who digs into real-time compliance reports and error logs.

An overview of LTE/LTE-advanced technologies, and how ModemManager will work with LTE devices.

3GPP Long Term Evolution (LTE) is the new standard for high speed data communications, an evolution of the 3GPP-family of standards (GSM, UMTS...), but adopted also by CDMA networks as the next 4G technology. ModemManager is a project running under the freedesktop.org umbrella, which works with NetworkManager in order to provide easy setup of broadband mobile connections in Linux-based systems. The new 0.6 release of ModemManager will be able to handle mixed CDMA/LTE and GSM/UMTS/LTE devices. This talk will provide an overview of the new LTE and LTE advanced technologies, from both network and device points of view; present the new features arriving with this technology; and describe what is being done in ModemManager to be able to manage 4G devices.

During this talk you will hear a short introduction what this room is about and which talks to expect during the day. In case there are any last minute changes you will hear about them during this talk.

Neil and Robert will discuss their own experience of writing a Wayland compositor, where they have been adaping the Gnome Mutter compositor into a hybrid X and Wayland compositor. The talk aims to provide general guidance on writing a hybrid X and Wayland compositor without going into many Mutter specifics.

A short introduction to the Perl devroom schedule

Moose is a post modern object system for Perl 5. It removes the tedium of writing object oriented code and gives developers powerful tools to express themselves. This talk is a bare bones essentials primer to getting a developer's feet wet with Moose. It will cover class construction, roles, attributes, and type constraints.

Many MySQL users have already put MySQL 5.5 in place and soon (2012) MySQL 5.6 will be GA! In this talk we will have a look at the New MySQL 5.6 Features which will come: InnoDB enhancements, Partitioning, Performance Schema and the new even more stable binary logging...

This will be a introduction to what our game is all about, and a showcase of the new features we have in our latest release and what can be expected in the next release. I will also touch upon what happened with Nexuiz and our reasons to fork.

Room opening talk

MINIX 3 is a BSD-licensed operating system focused on dependability. To improve the user experience, the MINIX team has been working to provide a more BSD-like environment on MINIX 3. This talk will describe our current progress on this front and our plans for the future.

In GNOME, accessibility is a core value that touches all aspects of the system. [1] From the infrastructure, to the graphical toolkit, to the applications, to the assistive technologies, accessibility has been a central consideration from the very early days. On April 2011 GNOME 3.0 was released, and although GNOME and the accessibility made a huge effort, the accessibility support was not ideal. But not are bad news. Finally the accessibility technologies are starting to be used from the two main free desktops. AT-SPI is starting to be used on KDE distros, and Orca is starting to be functional with Qt apps. Since GNOME 3.0 a big effort was done in order to improve the situation. At the moment of this proposal writing an ATK/AT-SPI2 hackfest is being organized, in order to fix the issues from the framework itself. The purpose of this presentation is explaining: * Introduce accessibility on GNOME. * Briefly explain the status towards GNOME 3.4 * Summarize the output of the ATK/AT-SPI2 hackfest * Compare GNOME 3.0 vs GNOME 3.4 * KDE status and cooperation * Future [1] http://library.gnome.org/devel/accessibility-devel-guide/nightly/gad-how-it-works.html.en

USB redirection is using USB devices attached to a real machine inside a virtual machine (guest). The focus of the talk will be the special case where the USB device being redirected is not attached to the physical machine hosting the virtual machine, but to some other machine. The talk will present and discuss the ongoing work to create an FOSS solution for this, getting this merged into upstream qemu, as well is integrating this into Spice and the Spice-client. The intended audience are people who are interested in usb in virtual machines (vusb) both developers and users. The audience is expected to be familiar with generic virtualization concepts, but no deep technical knowledge is required.

The purposes of this talk are: * To inform people about the new USB redirection support in qemu and Spice * Get feedback for future versions * Hopefully get people to use Spice and maybe even become contributors I gave the same talk last year, but quite a few things have changed: * USB-2.0 support * Integrated into Spice

The NOVA virtualization architecture is comprised of a microhypervisor and a capability-based multiserver userland with a specific focus on enabling secure and efficient virtualization using x86 hardware virtualization extensions (VT-x, VT-d, SR-IOV). It does so by moving almost all of the actual "virtualization" into a per-VM userspace component that is not in the Trusted Computing Base of other virtual machines. This talk will give an overview of NOVA's unique execution model and API with a strong focus on how this enables efficient execution of a VMM. Specifically, this talk will cover how tasks and threads are realized in NOVA, how communication between threads works, how VM exits are handled in NOVA and how this extends to SMP machines.

Showing simple ways to realize REST services in smalltalk. Combining routing, media type handling and meta tools to make REST an easy thing to do.

Web and online social graphs have been rapidly growing in size and scale during the past decade. In 2008, Google estimated that the number of web pages reached over a trillion. Online social networking and email sites, including Yahoo!, Google, Microsoft, Facebook, LinkedIn, and Twitter, have hundreds of millions of users and are expected to grow much more in the future. Processing these graphs plays a big role in relevant and personalized information for users, such as results from a search engine or news in an online social networking site. The Apache Giraph [1] project is a fault-tolerant in-memory distributed graph processing system which runs on top of a standard Hadoop [2] cluster and is capable of running any standard Bulk Synchronous Parallel (BSP) operation over any large generic data set which can be represented as a graph. Apache Giraph is a loose implementation of Google Pregel but can be added to any Hadoop job pipeline as a normal MapReduce job. Giraph entered the ASF Incubator in July 2011, where it has enlisted the aid of committers from Yahoo!, Facebook, LinkedIn, and Twitter. The talk will describe why running iterative MapReduce jobs for graph processing is not well suited for typical MapReduce jobs, introducing the reason why Google designed Pregel at first place. Next, the BSP model and how it is applied to graph processing will be explained. The last part of the talk will be dedicated to Apache Giraph, with a description of the programming model (i.e. the API, some typical examples such as PageRank and Single Source Shortest Path) along with a technical overview of how the architecture of Giraph works and how it leverages the Hadoop infrastructure.

Linker, compiler, runtime linker and the kernel can be improved to start applications significantly faster.

Optimizing application startup is hard, even measuring how long an application takes to start is a non-trivial problem. This talk will consist of 3 main parts: 1. Ways of measuring IO patterns [on startup] using systemtap, gdb, valgrind 2. How to optimize IO patterns on startup given the limitations in existing tools 3. A list of proposed changes in the kernel, ld, ld.so, gcc that could significantly speed up application startup on Linux. Additionally, the talk will compare application startup on Linux against other major platforms.

Different users stories like delcampe and Pierre & vacances

Developers comfortable with Moose typically look back on their first projects and cringe at some of the more naive choices made simply because they were unaware of better ways. Learn to avoid some common pitfalls and save time with knowing: when to use delegation and when to use role composition, common MooseX namespaced modules that simplify implementation, native attribute traits, and designing with an eye toward Inversion of Control.

Asterisk 10 added many new features, and includes substantial automated testing.

Asterisk 10 was recently released, and incorporates many new features, including nearly unlimited support for codec formats and sample rates, wideband audio conferencing, and much more. In addition, the Asterisk project team has built a large suite of unit and functional tests that are now run against each Asterisk release. This talk will cover the major new features of Asterisk 10, and also cover how the Asterisk testsuite is developed and used to improve the code quality of each release.

Do you think that High Availability is all about MySQL Replication? Have you tried to alter your tables to NDB to drink at the holy grail of the shared nothing architectures? High Availability is #1 request for MySQL Servers, even more popular than scalability and performance. In this presentation we will talk about old and new tools to provide HA, automatic failover and disaster recovery for MySQL - there is a solution for every need.

Pkgng is a completely new package manager rewritten from scratch. It aims at replacing the old pkg_install. It is developed on top of new libpkg which is the high level library that does all the package management, it brings new features such as safe upgrade, (multi) repository support, integrity checking and more. It has been designed to be extensible while remaining fully compatible with the current FreeBSD ports tree.

I have just finished redesigning the Debtags website, consolidating a 9 years long history of bringing categories to a large and complex distribution like Debian. There is more to Debtags than meets the eye: interesting library science concepts, anonymous submissions, an efficient review workflow, a fully automated tagging engine, dynamically generated tagging hints, fancy tag search algorithms. On top of that, there is not much that is Debian-specific in the new codebase, so if you are interested in implementing categories on your distribution of choice, this could give you quite a head start.

Pharo is slowly but steadily emerging. A more robust and cleaner infrastructure has been put in place. In this session we will describe the steps achieved so far in Pharo and the next ones we want to achieve: like having a better FFI, integration process, smaller kernel, new scalable canvas API. In addition we want to give the opportunity to pharoers to ask questions, raise points of discussions.

Wayland is a next generation display manager that is hopefully the future for graphics in the Free Desktop. It provides an opportunity to avoid some of the historical baggage associated with X - and enable smoother and more flexible user experiences. In this talk i'll show of the status quo of various toolkits running on Wayland - including GTK+, Clutter, Mx and with a special guest appearance from Tiago Vignatti to show off the state of the QT port. We'll talk about what works and what doesn't and what application level programmers need to think about when porting their application to run under Wayland. In particular input is a field where X has lagged behind current technology - Tiago will show how the exemplary input architecture in Wayland can be exploited to create compelling modern user experiences.

XQuery has been designed by the W3C as a general purpose XML processing language. Although XQuery is mainly known as a query language for XML collections, it is a fully fledged programming language useful in a variety of architectures and environments. With an extremely powerful support for database queries, scripting, and full-text search, XQuery is providing a unified framework for building web applications. The aim of this talk is to briefly introduce some of the new language features in XQuery 3.0 and demo how XQuery & HTML5 can work together to build applications that are 300% awesome.

The Cassandra distributed database runs on the JVM, which in many ways is a huge productivity boost. However, the more you care about performance, the less you can afford to let abstractions like i/o and memory management exist as black boxes. This talk will cover how Cassandra has gone beyond the interfaces provided by the JVM to achieve higher performance in three areas. First, how Cassandra uses platform-specific features such as posix_fadvise, munmap, and mlock. Second, how we tune memory management to avoid pain points in common garbage collection designs, including in OpenJDK. Third, how Cassandra uses the JDK's instrumentation hooks to measure the real size of on-heap structures and make better decisions about what to keep in memory without error-prone manual adjustments.

Brief introduction to the Ganeti cluster virtual machine manager, latest features and suggestion for creating a production environment.

Now that DRM KMS plane support has landed upstream, it's time to start using it in higher level projects. This talk will focus on how overlay planes will be incorporated into the Weston compositor design (Weston is the open source project implementing a Wayland compositor). It will review the motivations for the work, current status, and hopefully a demo.

This presentation will walk the audience through the design principles of an isometric role playing game engine. The specimen to be dissected is an actively developed yet fully playable game called FreedroidRPG. A general presentation of the game will be made, before the architecture of its engine is exposed. Examples of good and bad design decisions will be provided, and the way to pull out of ugly situations without compromising stability explained. The game covers most of its objectives but some open questions remain which will be exposed to the audience.

One important aspect of user experience, especially on mobile devices, is how quick an application can start up and show what the user requests. This talk will explore the challenges and solutions under works to make the Firefox startup a much better experience on Android.

eLuaBrain is an experiment in educational computers with a number of unique features. It is a low cost, completely autonomous computer designed to work with low cost peripherals (PS/2 keyboard on input and a standard VGA monitor on output). Its main goal is to offer another perspective on education in general and training IT professionals in particular. Modern computers are difficult to understand at the hardware level even for experienced IT professionals; at the same time, there is a growing trend in most modern computer languages to completely ignore the hardware on which they run and focus entirely on programming concepts instead. By contrast, eLuaBrain offers the whole experience in a single package. Its hardware is easy to understand (and hack) and the on-board software offers easy ways to interact with the hardware, thanks to the features provided by the eLua open source project. eLua is built around the programming language Lua, which is a relatively compact language, but comes packed with lots of features, which makes it very suitable for teaching programming concepts. With eLuaBrain it is natural to teach programming and hardware design in parallel, which gives students a complete image on the hardware-software interactions. At the hardware level, it is built around a 32-bit CPU (a Cortex-M3 core) with 1M of external RAM. It also features TCP/IP network connectivity, SD card storage and a low power radio link. eLua brings a MCU-friendly Lua interpreter and hardware support modules into the equation, while the built-in code editor and on-line help system make eLuaBrain a truly autonomous platform. A very low footprint, UDP based remote file system can be used to easily share files with any desktop machine. The hardware and software behind eLuaBrain are open source, free to use for both commercial and non-commercial projects. eLuaBrain comes with a number of sample applications meant to demonstrate the platform features and to serve as a starting point for future applications. These include a RSS reader, an IRC client, a Web server and (of course) games. This presentation will start with an overview of eLua, after which we'll take a deeper look at the implementation of eLuaBrain at both hardware and software level and its future directions of development. If time allows and the right hardware is in place, a live demo of the platform will also be provided.

In this talk I will introduce the Matahari project, an interface for system management APIs of all kinds.

I will discuss the architecture of the Matahari ecosystem and how the use of AMQP as a transport layer allows it to scale to large collections of servers in the Cloud. I will also describe the ways in which developers and sysadmins can get involved in the Matahari ecosystem: by creating agents to provide access to existing APIs through Matahari; by creating their own APIs; by writing their own clients to interact with agents; and by interacting through a command line shell or script.

The openSUSE community started to revive its ARM port recently. This talk will show how do we work on our ARM, what troubles we were facing so far and what is the current status of the port and what our hopes are for the future.

Perlude (formaly Lazyness) steal haskell prelude keywords to give perl a convenient way to deal with generators the way haskell uses monad. It actually adds a pipe feature to perl. Lot of problems can be solved with smaller, more reusable and easier to maintain code.

Today's operating systems try to find a balance between seemingly conflicting goals. Ease of use is traded against security, resource utilization is traded against resource accountability, and system complexity is traded against scalability. For example, SELinux is ill famed as hard to use and consequently remains widely unused. As another example, isolation kernels minimize the complexity of critical system software but at the cost of limiting these solutions to static applications. The Genode OS architecture shows how these apparently inherent conflicts can be solved by operating-system design.

By combining a recursive system structure with capability-based security, mandatory access control becomes easy to deploy. At the same time, the trusted computing base can be minimized for each application individually such that the attack surface for security-critical system functions gets reduced by orders of magnitude compared to existing approaches. Furthermore, a concept for trading physical resources among processes allows for dynamic workloads while maintaining quality of service. That is not just theory - the system is ready for demonstration and its developers are planning to use it as development environment by the end of 2012. After a brief introduction of where Genode comes from, the main part of the talk will be focused on the OS architecture and give a glimpse at the implementation via live demonstrations. Finally, the talk will briefly discuss the planned steps towards using Genode as general-purpose OS.

Sick of ludicrous security theater? Banish it in your organization!

Security is frequently done in an ad-hoc manner, either entirely without a formal threat model, or with one, but without any attempt to connect mitigations to the threat model. Even in those organizations which have a threat model, it's created in secret and updated in secret, if at all. I'll present the down sides of the current approaches, and present a new way to approach modeling threats.

Graphs are becoming increasingly popular as ways of modeling a wide variety of systems. As such, the label "graph processing" also covers a range of objectives and architectural constraints. At [Linkfluence][http://us.linkfluence.net/], we use graph processing on datasets produced with very different systems (Web crawler, Twitter and Facebook API, feed aggregator, etc.) We spend a lot of time doing exploratory programming, trying to use our eclectic datasets in interesting ways, and processing our data in asynchronous workflows. We have come to see [Hadoop][http://hadoop.apache.org/] and the processing framework [Cascalog][https://github.com/nathanmarz/cascalog] as essential tools in our toolbox when dealing with graphs, since it gives us architectural flexibility, scalability and the possibility of rapid prototyping. Cascalog is an open source framework built on top of Hadoop and [Cascading][http://www.cascading.org/]. Its syntactic and semantic roots come from Datalog and Prolog, which have been succesfully applied for a long time in the manipulation of graphs. Also, its ability to directly embed the expressive [Clojure][http://clojure.org/] language allows to very easily define custom operations and ad-hoc processing. In this talk, we will present the framework, consider its advantages and drawbacks when compared to other approaches, show concrete exemples of usage for graph processing and how we use them to complement graph databases.

JRuby is Ruby on the JVM, and the first mainstream JVM language to make use of invokedynamic. We also have worked around limitations in OpenJDK's APIs (process mgmt, IO, native POSIX support) in many clever ways. Lots to talk about here.

Traditionally Mozilla measured Firefox performance with a set of performance tests called Talos. For features not covered by Talos developers benchmarked individual features themselves. However, it turns it is extremely difficult to design a representative testsuite. Reproducing performance problems is often harder than fixing them. Telemetry is a way to measure Firefox performance & usage in the field. It allows developers to insert lightweight probes and then use them to track how Firefox behaves in the wild. We have been using Telemetry to improve Firefox since version 7. We will soon roll out Telemetry to addon developers so they can benefit from the same infrastructure. This talk will cover how Telemetry is used and the kinds of problems it helped us fix so far.

A typical recent version of a MySQL-based product focuses on letting you run the same queries on more CPU cores, or having better replication. MariaDB 5.3 is very different: its focus is the new query optimizer features that let you run queries that were traditionally considered off-limits for MySQL.

MariaDB 5.3 is getting stable: 5.3.3 Release Candidate has been released in December, and one can expect another, almost? stable release in January or February. This talk will show: - What kinds of traditionally no-no queries are now okay to run, - What optimizations are used to execute them, - How the new optimizations behave for typical kinds queries and popular benchmark suites. In conclusion, we will discuss relationship with other MySQL branches: which of these new optimizations will also be in MySQL 5.6, what are the differences between MySQL and MariaDB variants, and what one can expect to see in Percona server.

How to build a distribution on foreign hardware without to add support cross compile support in each package.

RestComm and TelScale make it possible for application developers to easily connect voice applications to Web 2.0 services and networks.

The evolution of cloud computing has given birth to new incredibly successful applications. Cloud based voice and media services can create similar opportunities and add tremendous value to existing web applications. Traditionally voice and media services require capabilities that are well beyond the scope of typical IT department, but Telecom engineers are no longer needed to make enticing value-added services. Any web developer can make telecom apps in minutes and integrate them with Web 2.0 and social networks. This session will explore how this can be made possible through the use of RestComm for adding voice and text to current cloud-based applications and services and explain how RestComm is backed by a powerful and autoscalable PaaS based on Mobicents.

A short introduction runtime related efforts and technologies available at Eclipse.

EclipseRT is a top-level project at Eclipse which groups together various projects that are all related to runtimes. This talk will give a short introduction to EclipseRT and to the projects available there.

Boxes is a new GNOME application to create and access local and remote systems, such as virtual machines or remote desktop. A local machine is powered by KVM & Spice, and you can access remote desktop via libvirt, SPICE and VNC (and more coming). Boxes is made for you, developers, contributors, and users of application running on other systems. During this talk we will demo latest version and describe the design of Boxes. We will discuss the importance of Boxes as part of the GNOME project. Finally, a list of missing features and the roadmap for the next cycle will be presented.

Game architectures used to be designed in an inheritance-based approach, which has proven to be difficult. The current state-of-the-art is a component-based architecture that allows loading all game entities from a separate data source. This enables easier testing and modularization of the code. It is also beneficial for the game designer as it weakens the game designer's dependency on the programmer. This is important for content creators of open-source games, so they can easily add their new content to the game, without relying on somebody else to help them. This talk will outline the reasons to use a data-driven and component-based architecture, give examples of architectures used in popular open-source games (Wesnoth, MegaGlest, 0AD and Unknown Horizons) and explain how Unknown Horizons moved from an inheritance-based approach to the new component-based architecture.

The is a technical talk about how Xspice integrates the spice-server library into Xorg via a small rewrite of the xf86-vide-qxl driver, resulting in a standalone X and Spice server. Alon will briefly describe his future plan to use hotplug export a running Xorg via Spice.

We’ll take close look on how to offload MySQL server with queries which might be efficiently handled on the Sphinx side. Real-world examples for handling non-Full-Text queries including geodistance search, time segments implementation, using multi-value attributes and more. We’ll also learn how to keep massive text collections away from MySQL databases and how to utilize power of Sphinx on Full-text queries.

Aseba is an open-source project providing a set of tools that allow beginners to program robots easily and efficiently. Technically speaking, Aseba is an event-based architecture for distributed control of mobile robots. It targets single- or multi-processor robots and simulations. The core of Aseba is a lightweight virtual machine tiny enough to run on microcontrollers. With Aseba, we program robots in a octave-style scripting language using an integrated development environment. This environment provides several features important for robotics, such as real-time inspection of sensor/actuator data, integrating plotting, on-typing compilation, distributed debugging, and instant code upload to the robot. Compared to alternatives (for instance Arduino and Lego Mindstorm), Aseba focuses on text-based programming but takes advantage of the tight integration between the environment and the robot to provide an interactive robot programming experience. Aseba stems from research in miniature mobile robotics, in which small robots with multiple microcontrollers have risen architectural questions (see papers under links). In addition, Aseba has found a natural application in educational robotics with the Thymio low-cost robot. We have also demonstrated Aseba in simulation and on a group of e-puck robots. Aseba integrates with D-Bus and ROS, allowing access to microcontrollers from high-level languages. I am the initiator and maintainer of the Aseba technology and one of the most active contributors. I propose to present a talk with the following content: * Genesis, why did we develop such a thing. * Technical overview, with discussion of the design choices. * Presentation of the Aseba in the robotic-research context. * Live demonstration of Aseba in the educational context using the Thymio robot. * Future directions. * Conclusion and question answering. I started developing Aseba as part of my PhD work in the Mobots research group at EPFL. Currently, a community comprising members of the Mobots group, of the mobsya association, of the ASL at ETH Zürich and other individuals maintain and further develop Aseba.

The oVirt Project is an open virtualization project providing a feature-rich server virtualization management system with advanced capabilities for hosts and guests, including high availability, live migration, storage management, system scheduler, and more. oVirt provides an integration point for several open source virtualization technologies, including kvm, libvirt, spice and oVirt node. oVirt was launched in November 2011 as a fully open source project, based on assets from Red Hat Enterprise Virtualization Manager platform. The project has an open governance model, and initial board has members from IBM, Cisco, Netapp, Red Hat and SUSE. The session will introduce the project principles, scope, demo and architecture.

Do you feel lost after reading CFEngine tutorials? Does promise theory seem to be distant from the particular CFEngine constructs?

In this talk CFEngine 3 operators will be dissected, analyzed and mapped to the ideas in the promise theory. Promise theory is a model of voluntary cooperation between individual, autonomous actors or agents who publish their intentions to one another in the form of promises, which is particularly suited for configuration management in distributed systems. Promise Theory was proposed by Mark Burgess in 2004, further developed in the following years and implemented in CFEngine 3.

For many years, syslog-ng was part of many distributions but stuck at ancient software versions. My task was to help distributions to update their syslog-ng packages and now to keep them updated. This is a two way process, as while distros receive many help, we also get a lot of useful feedback and ideas, which influence the development of syslog-ng. Using syslog-ng as an example, I'll try to show how upstream can work with distributions for the benefit of both sides.

FreeBSD 10 is expected to have a completely new C++ stack. The reasons for this are partly legal and partly technical. The existing stack is covered by version 2 of the GPL, but newer versions from upstream are GPLv3. The new C++11 standard means that shipping an old version of the GNU stack is no longer acceptable. This talk will cover the various parts that were required for replacing this stack, the challenges and missing pieces that needed implementing and the advantages of the new stack.

Most of the Free Software world currently uses the C++ stack provided by the GNU project, including the C++ front end to the GNU Compiler Collection and libstdc++, the GNU implementation of the C++ standard library. In 2007, these projects switched to version 3 of the GNU General Public License. As a result, newer versions have not been imported into FreeBSD and other projects with similar licensing conditions. GCC 4.2.1 and the associated libstdc++ release are the most recent that can be shipped with these platforms. Since this release, a new version of the C++ standard, C++11, has been published. This includes a number of significant changes to both the language and the standard library. Some, such as r-value references, allow much more efficient implementation of some fundamental parts of the standard template library and make a significant reworking - if not a complete rewrite - desirable. These two factors, the license and the need to support the new standard, made it desirable for FreeBSD to switch to a completely new C++ stack. This includes a variety of components. At the bottom sits the C++ runtime library, responsible for providing features such as exception handling and run-time type information. On top of this is the C++ standard library, which provides the classes that the standard mandates. None of this, of course, would be any use without a C++ compiler. This talk will examine each of the components in the new, permissively licensed, C++11 stack, including libcxxrt, libc++, clang / LLVM, and the modifications that were required to FreeBSD to support all of these. Some of these libraries required writing from scratch, while others required effort to port or integrate. They all depend on various features that are not specific to C++, some of which already existed and some of which required implementing from scratch.

The Eclipse community's support for C and C++ programmers is continuously improving. Coupling this support for editing and debugging with integration of existing Linux tools for profiling and analysis gives C and C++ programmers a powerful, one-stop-shop environment. Valgrind, OProfile, and RPM integration? This isn't your grandfather's Eclipse. Come see it in action!

Amber is an implementation of the Smalltalk-80 language that runs on top of the JavaScript runtime. Amber brings client side scripting to the next level. Imagine developing directly in an IDE in your web browser: write unit tests, debug, inspect, save and run your code without hitting the refresh button. In this session, we will: - Show how to get started with Amber - Show how the JavaScript integration works - Show examples of how to access and quickly wrap existing JavaScript libraries (e.g. Google Maps, Ace editor) - Discuss how Amber can be easily incorporated into existing webapplications - regardless of the back-end (Ruby, PHP, Seaside, etc) and how it can co-exist with existing client-side JavaScript - Show some nice applications written in Amber

LPI holds an open attendance item development workshop for the new exam "Linux Essentials". G. Matthew Rice, Director of Product Development at LPI, will guide this workshop. Participants are invited to write real exam questions and answers for this new exam during the workshop. The purpose of the Linux Essentials Program is to define the basic knowledge required to competently use a desktop or mobile device using a Linux Operating System. The program will guide and encourage youth and those new to Linux and Open Source to understand the place of Linux and Open Source in the context of the broader IT industry. More information about the Linux Essentials Program are at http://wiki.lpi.org/wiki/LinuxEssentials and at http://wiki.lpi.org/wiki/LinuxEssentialsProgramme

MiniPerl6 ("perlito") is a subset of Perl 6, which was designed as a light bootstrapping language. MiniPerl6 is now self-hosted in Javascript, Lisp and in Perl 5.

Du to recent late flu of Pablo Parega catch he is not able to attend FOSDEM this year. In substitution of that, we are going to have a Birds of a feather. Thanks to the awesome A-Team, the organisers of this room aim to have a Birds of a feather, with the following agenda, but totally open to contributions. - State of the art. - Things that can, or have, to be improved. - Future trends on Graph Processing. Take the chance to attend if interested on Graph Processing, or if you are working and contributing to the community! I am sure this discussion can give all of us great ides to work on! See you there! A-Team

HelenOS is a general-purpose multiserver operating system written from scratch. It is based on a custom microkernel, SPARTAN, which currently runs on seven different CPU architectures (ARM, IA-32, x86-64, Itanium, MIPS, PowerPC and SPARC V9) . Most system services (e.g. device drivers, file systems, networking) are implemented in regular user-space processes which communicate via asynchronous messaging. First, the talk will briefly introduce the HelenOS project history and community structure. Second, we will briefly talk about the major technical areas and specifics of the system (boot and kernel, IPC mechanisms and naming services, devices and filesystems). This part will be supported by demos of the running system as well as by showing the structure of the source code. Last, we will look at what functionality is already there, what is currently being actively worked on and what are the future plans, which aim toward making the system self-hosting.

By using the sip:provider Community Edition, an open source VoIP soft-switch leveraging powerful and widely used open source components, we will in 15 minutes create a VoIP deployment from scratch in order to provide future-proof voice and video communication services, preceded by an introduction into the system architecture.

There are various open source components (e.g. Kamailio, Asterisk, Freeswitch and Sems) available to build a reasonably sized VoIP service from scratch. There are also some administrative web interfaces (e.g. Webmin, Siremis), allowing you to control the most basic things in such a system. And in order to escape the lab stage, you can even put an open source billing engine (e.g. a2billing) into the mix. Since your customers would like to manage their accounts and features, you will then develop a customer self-care interface as well. Time to market: at least two months. Feature set: basic. Service quality: uncertain at best. Future-proof: not. There is a solution to that though. During this talk, I will present how to deploy a solid VoIP Provider platform from scratch in just a few minutes, using the Sipwise sip:provider CE (SPCE) v2.4. The SPCE is a free and open source soft-switch based on Kamailio, Sems and Asterisk, providing fully featured and seamlessly integrated administrative and customer-self-care web interfaces, SOAP/XMLRPC provisioning APIs, a flexible rating engine and a huge load of subscriber features like conferencing, voicemail, call forwards, block lists etc. On reasonable hardware, the SPCE can serve 50k subscribers and more. As an introduction, I will outline the basic elements involved in a VoIP deployment. Then I will dive into the architecture of the SPCE, showing the building blocks and their interaction. Finally, I am going to do a live presentation on how to configure an SPCE instance for a typical deployment.

Amarok is the old fart among the Free Desktop music players by now. Newfangled software with "social" and "distributed" in their summeries has come and taken some of the buzz from our old wolf. But Amarok is still kicking! The recently released version 2.5 is better then ever and even comes officially supported on Windows. But a project is one foot in the grave if it does not have plans for the future. Come gather around the warm buzzing projector kids, to hear the story of Amarok's future on small pocketable devices and large clumsy desktops.

LibrePlan is a collaborative tool for planning, monitoring and control of different types of projects. LibrePlan is a project management tool based on Gantt diagrams. It is also a web-application. Thanks to its rich web interface, LibrePlan provides an user experience similar to desktop applications like MS Project.

When planning a project, it's very common to find yourself managing different resources working in different projects at the same time. LibrePlan was designed from the very beginning to deal with scenarios like this, where resources and projects have a high degree of connection. This requirement makes LibrePlan a little bit different to other existing tools. LibrePlan is not an isolated island. It's usual that input data needed by LibrePlan may be stored in other systems. In that case, LibrePlan can be fed with these data, thanks to its web services import capabilities. On the other hand, LibrePlan can feed other applications if necessary or even communicate with other LibrePlan instances. LibrePlan is a free software application licensed under the AGPL. One of the great assets of LibrePlan is its open development process, always driven by the LibrePlan community. The LibrePlan community engages companies and individuals working together hand by hand to build the best free software project management tool. If are keen to know more about LibrePlan, if you are a developer and would like to collaborate with the LibrePlan community or if you are a company and would like to start using LibrePlan for planning your project, please come to see us and learn more why LibrePlan is important for you.

Several distribution projects have existing initiatives and programs in order to coordinate and/or fund local communities as well as shipping or producing promotional material, going to events to promote the project, etc... Some projects are currently looking into setting up something like this, and others are rethinking their current model. Those programs all have their differences, but achieve pretty similar goals. In this session, we will bring together a bunch of people from different projects who are in charge or actively participating in such initiatives, in order to briefly present what they are currently doing in their project and, more importantly, share experience about what has worked well and what hasn't in an open discussion session. Let's learn from each others' ideas and mistakes.

Often when people ask the question "Can I legally do that?", they mean "Will someone sue me if I do...?". Sadly the answer is that if something is successful, no matter what and how you did things, at some point someone will just try and sue, just to see if they can get some part of the success/money. This talk will describe some of the copyright, trademark and patent issues a Free Software hacker dealing with the core java platform may encounter. And some techniques we as a community can employ to make the chances of individual hackers being the target of a lawsuit smaller and how to make it harder for someone to take down one of our core java platform projects.

The oVirt project is an open virtualization project providing virtualization management with advanced capabilities. The oVirt Engine Core is the main component responsible of managing all business logic and entities from physical hosts, data-centers, users and virtual machines. In the session, an overview of the the engine infrastructure will be given, with explanations of the internals – main components that build the engine, their roles and how they work together. The session should make the audience familiar with the project and give a basic understanding of the building blocks.

A General overview of the new data collection module, as well as an explanation of the rationale for adding it.

Mozilla needs to have a clear, data-driven understanding of what using Firefox is like for the majority of our users. This allows us to make decisions about where to prioritize development, investigate new or poorly understood problems, and improve the user experience. The Metrics Data Ping is a new project to address this need.

Tired of the intricacies of circular replication? Dreaming of real multiple masters solutions for MySQL replication? Dream no more. Tungsten Replicator, a free and open source replacement for MySQL replication, can build clusters of asynchronous nodes in a matter of minutes. This workshop will explain the basics of Tungsten Replicator, and it will show how to start your multiple master cluster in a few minutes. There will be examples of several topologies: from the simplest bi-directional replication to the ambitious all-to-all (every node is a master), fan-in (multiple masters to a single slave), the star (a central hub connected to several bi-directional masters)

This talk is aimed at developers porting toolkits to run on Wayland. It will include an overview of some of the lessons learnt from porting various toolkits over to Wayland and provide an opportunity for developers to raise questions.

The Qt project was established in October to drive further development of Qt as an open source project. The main development effort of qt-project.org goes into Qt 5, the next major version of Qt that is currently being developed. The talk will explain the setup of qt-project.org, and how people can participate and contribute to the project. It'll also give an overview over Qt 5.

Topics: partitioning of large calculations, computation networks, python, celery, rabbitmq, redis

The open source OpenQuake seismic calculation engine (http://openquake.org/) is developed and maintained by the GEM foundation (http://www.globalquakemodel.org/) which is a public-private partnership that drives a collaborative effort aimed at developing and deploying tools and resources for earthquake risk assessment worldwide. Seismic hazard calculations can be massive making it necessary to partition and distribute them across a compute network. The OpenQuake engine (http://openquake.org/) partitions seismic calculation and uses - celery - rabbitmq - redis to push the tasks into the compute network and to collect the results. There were a number of lessons learned while scaling up OpenQuake to perform seismic calculation for the whole of Europe and I will touch upon the most important ones.

The WorldForge Project was founded in 1998 on many dreams of online world with freedom, both in terms of price and from the constraints of proprietary software. Pulled in many different directions by often conflicting visions of what the perfect online role playing game should be, the developers have been forced to come up with novel solutions allowing unprecedented flexibility to both the game designer and the player. Using data driven and procedural technologies, systems have been developed that remove the need for gigabytes of patches that are associated with proprietary commercial titles, and allow every host to configure their own game rules in a unique world. In this talk one of the projects longest standing programs will describe some of these technologies, including the possibilities they unlock and examples of their use.

The FreeBSD Project has been actively working to incorporate tools from the LLVM project into our base system including clang, libc++, and possibly lldb. This talk will cover our efforts so far including our plans to ship FreeBSD 9.0 with clang in the base system. I will cover both our current work to replace GPL licensed components with BSD(ish) licensed components and future or experimental work to incorporate new technologies made possible by LLVM.

LemonLDAP::NG is a free WebSSO software written in Perl and using Apache engine. It supports CAS, OpenID and SAML 2.0 protocols.

Xorg allows compositors to run on efficient GPU hardware. It is possibly to deploy GPUs for low power consumption colour correction of the whole desktop. The talk will introduce in the topic by the CompICC colour server implementation and give a overview about used techniques and concepts. It will try to outline next generation desktop colour management and what is needed to get colour management well supported in graphics servers and deployed by toolkits and applications.

This talk will present OrientDB open source project and its capability to handle persistent graphs in different ways. OrientDB presentation Java Graph Native API SQL+graph extensions HTTP API Blueprints API Gremlin usage Console tool Studio web tool

After deploying an embedded system, it is desirable to be able to upgrade the firmware, in order to add new features or to solve bugs. However, it is often difficult and expensive for a technician to get physical access to the device(s). Therefore, it should be possible to perform the upgrade remotely, which also means that it should be secure and survive any kind of failure. In the course of their career the consultants at Essensium/Mind have encountered many failure paths and solutions of how to deal with them. This includes issues like bad firmware, power failure, communication problems, security issues, flash corruption and bootloader bugs. Solutions include fall-back firmware, watchdogs, journalling filesystems, backup media and package managers. But in the end, it turns out that there is no silver bullet and that the best upgrade approach mostly depends on how the system is used.

VDSM, the cluster node agent, is in charge of executing, managing and monitoring all the virtualization tasks needed in a large scale deployment. This session will give an overview of the project, including: * VDSM and its responsibilities * Who should use VDSM * Architecture, packages and infrastructure * Short description of interesting APIs and use cases * Roadmap and how to contribute

By any measure, Eclipse has been a very successful open source community, and it has certainly contributed immensely to the worldwide success of Java. It has also been for many years, one of best examples of a vendor-neutral, free Java community. But there is one thing in particular that sets Eclipse apart: it ALWAYS ships on time. For eight straight years, the Eclipse community has shipped its major release on time to the day. How the heck does that work? This talk will focus on the processes, community interactions, and most importantly, the cultural aspects of Eclipse that makes this possible. The not-so-subliminal message is that OpenJDK would be well served to emulate Eclipse in its predictability.

This talk will go through the components of the MySQL Cluster architecture. How MySQL Cluster fits into the standard MySQL through the storage engine interface, as well as the different node types in the MySQL Cluster and how they work internally to guarantee high availability. We will also take a look at the resource utilisation within the nodes and how that is managed and configured.

An overview of how Mozmill is used to test daily Firefox builds in a CI environment. The talk also includes our plan to expand this testing to l10n builds triggered by check-ins from localizers.

An overview of jQueryMobile, how it allows rapid development of mobile sites and some of the key pitfalls to be avoided. Examples showing how Seaside's component model and #show/#answer facilities map well onto a mobile site. What it takes to turn a mobile web application into a mobile application suitable for a mobile app store.

This talk is to give an overview of what is involved in releasing Debian. It will cover policy, tools and an insight into what it takes to release the largest linux distribution.

The talk introduces LedgerSMB - its technical structure, its community, the direction of development and the vision of the developers.

LedgerSMB is a webbased ERP built with Apache, Perl and PostgreSQL, featuring general ledger accounting, receivables and payables management, budgeting, quotation and order management and more. It aims to be a platform to build businesses on: with existing installs running payment runs of 1000s of items each week it can be considered to be high performance being able to serve larger businesses. With a user community focus, the project strives to achieve easy installation and use to best serve small businesses and single person companies. The talk touches all of these subjects as well as describing the future direction of development.

This talk will cover progress with OpenJDK on ARM. It's basically a progress report, but with some technical detail about the changes needed for: * The new Hard FP ABI. * ARM 7. I'll also discuss the issues that arise from the Java Memory Model (also known as JSR 233.) The talk will then be in two halves, one part being very specific to Ed Nevill's ARM Assembler interpreter and JIT, and the other part will cover the ARM more generally. If there's any time left I'll also cover the upcoming ARM8 architecture.

Recent developments in using many cores and parallel programming that embraces non-determinism for performance

Much is discussed regarding query optimisers within database server, attention is not always paid however to the actual queries that are passed to a database server to execute and the value of those queries within an application context. No matter how good a query optimiser is it can not match the performance improvement that can be gained by not running a particular query at all, retrieving smaller result sets or running queries less frequently. We will discuss some methods to investigate the SQL your application is sending to your MySQL server, and examine some techniques to visualise the cost of the interactions your application has with the MySQL database.

This is a hands-on talk that will tell you how to do cool stuff with Thunderbird. There will be a demo addon so that you can play with the various snippets I explain; I will also cover some tips and tricks, as well as specific advice so that your addon gets accepted on AMO.

The SIP Express Media Server can be used to provide SBC-like functionality in various ways, and this presentation will demonstrate two of them.

SEMS, the SIP Express Media Server, is the media and application server counterpart to SIP Express Router aka Kamailio/OpenSER, the leading open source SIP Signalling server from iptel.org. Since 2004 SEMS has been used to implement classical value added services in VoIP networks like announcements, conferencing, voicemail and RBT, and converged services as web conferencing and voice message broadcasting. More recently, its integrated Back-to-Back User Agent has been extended and improved for flexibility and high performance, making it one of the few open source solutions for high volume session border control. But there's more to it: Thanks to its flexibility, it can also be used as core call routing element, and be a useful tool in various situations for the VoIP platform engineer. The talk will present the SEMS SBC functionality and typical performance numbers, and then show how developers can use the internal call control API to create custom call routing in the SBC with two examples: Using a RESTful interface, a web app server implemented with the Play! framework is used for user controlled call routing, and by accessing a blacklist database in REDIS, SEMS' SBC can be used to block SPIT.

The Pandora is a handheld produced to run Linux. It's not only a gaming device (it features gaming controls), but basically a full Mini-Linux PC the size of a Nintendo DS. It has come a long ways and many many issues occurred during the production. The mass production will finally start in Germany in February, making it easily available for everyone. This talk will give a small introduction to those who don't know what the Pandora is, explaining a bit about the history and the community behind it as well as showing what it can do.

You can find more information about it in my blog article: http://www.rene-pickhardt.de/graphity-an-efficient-graph-model-for-retrieving-the-top-k-news-feeds-for-users-in-social-networks/ and a demo can be found at http://gwt.metalcon.de/GWT-Modelling/#Home A key challenge of web platforms like social networking sites and services for news feed aggregation is the efficient and targeted distribution of new content items to the users. This can be formulated as the problem of retrieving the top-k news items out of the d-degree ego network of each given user, where the set of all users producing feeds is of size n, with n ≫ d ≫ k and typically k < 20. Existing approaches employ either expensive join operations on global indices or suffer from high redundancy through denormalization. This makes retrieving of different top-k news item sets for thousands of users per second very inefficient in a large network. In this paper, we propose a novel index GRAPHITY to remedy this problem. The GRAPHITY index is based on neo4j and allows retrieval of the top-k news items from a user’s ego network independent of the node degree of his ego network, thus reducing join efforts. In addition to efficient top-k retrieval, GRAPHITY does not introduce any redundancies in the content data.We prove that updates of the index are in O(1) and adding a new content item is linear in the user’s indegree. We compare the theoretical run time complexity of GRAPHITY against several baselines on two data sets of different characteristics and size. Our evaluation confirms that GRAPHITY is independent of the node degree d and network size n. In addition, GRAPHITY significantly outperforms the baselines in retrieving the news feeds as our theoretical examination predicted.

How the Jenkins project had to grow infrastructure overnight, and how a costly mistake doing things the wrong way forced us to migrate to managing our infrastructure with Puppet.

In early 2011 the Jenkins project became the Jenkins project, leaving behind an organically grown but Oracle (formerly Sun) operated infrastructure. An open source project with thousands of users had to grow an infrastructure practically overnight, initially doing things "the wrong way" by hand crafting machines. That was until a costly mistake forced us to reconsider and migrate to managing our infrastructure with Puppet from a publicly available shared Git repository. Besides Puppet, the Jenkins project also uses a number of other tools to help manage access control on GitHub, parts of JIRA, etc, all carrying on the very transparent and welcoming tradition the project prides itself on. In this talk I will discuss the ups and downs of switching an established infrastructure to Puppet, all within the public eye and with volunteer time and energy.

Existing virtualization solutions such as Xen, QEMU and usermode operating systems virtualize the entire OS. While this is useful in a machine room type of use case, it is unnecessarily heavyweight when the interest is in virtualizing only one kernel driver or one kernel service. This talk introduces the anykernel architecture and rump kernels, which allow to safely virtualize individual drivers and subsystems from a monolithic kernel. Rump kernels can be used in a variety of different configurations, such as an application library, a microkernel style server, or as a server over the Internet. We will go over a number of real world use cases and present results which show that in their application domain rump kernels are faster, smaller and more agile than full OS virtualization technologies.

The implementation is available in production quality code as part of NetBSD. A key point of the project is the use of existing drivers from a real OS, i.e. real-world hardened code.

Everywhere here and there you hear about MySQL synchronous Replication with Galera as a replacement for MySQL Master-Master Replication. But nobody has seen it yet in practice. In this talk we look at the architecture, the installation, the configuration and the pitfalls you have to expect with synchronous Galera Replication for MySQL during operation

The Qt framework is best known by most developers as a graphical toolkit library, which allows to build graphical interfaces with windows, buttons, checkboxes and drop-down lists. However, Qt is not limited to graphical application development and through this talk, we would like to highlight the multiple features that Qt offers to embedded Linux developers developping non-graphical applications. Based on the experience of a real non-graphical application developped for a customer, we will detail how Qt has helped integrating features such as communication with multiple devices over serial ports, communication with a GSM modem, XML parsing, HTTP requests, communication with Linux input devices, and more.

When Firefox crashes, it sends a report of that crash to Mozilla by default. This talk will look at what that data tells us and how the CrashKill team is working on improving stability based on analysis of those crash reports.

Workshop on how to use smart cards with popular open source software.

Since the famous [Tanenbaum-Torvalds debate](http://en.wikipedia.org/wiki/Tanenbaum–Torvalds_debate) the general public sticks to the golden rule of thumb: Microkernel systems, while nice and elegant, are just academic toys. Due to the infamous communication overhead and other self-imposed limitations, they are never going to be as useful for the general use (in terms of performance) as the good old monolithic systems. Since the 1990s many researchers (especially the people around L4) have struggled to lower the overhead using the most extraordinary tricks. Others have tried to apply the microkernel design to mission critical, safety critical and other niche targets, where the benefits of the microkernel design clearly outweights the drawbacks. And other folks spent years creating hybrid systems to get the best (and hopefully not the worst) of the both worlds. But are the drawbacks of the microkernels fundamental?

The way computers are designed, the way programmers think and the way the IT economy works have changed profoundly over the last 20 years. We no longer try hard to save every single CPU cycle and every single byte of RAM in every single routine. We acknowledge that spending 20 % more on a faster CPU and more RAM to run inteligebly designed software is a better idea than spending 20 % more each year on maintaing software with tons of ugly performance hacks and quirks. Our machines are massively concurrent and we tend to (or are forced to) think more in terms of effective parallel algorithms than just plain sequential throughput. So perhaps it is time to reconsider the true impact of the microkernel overhead given the present conditions and requirements. Key topics: - Reasons for the microkernel overhead - Qualitative and quantitative analysis of the overhead - Ways to minimize it - Ways to live with it - Ways to embrace it

Who are the people behind OpenIcc and what do they do for open source colour management? What are standards exist and are primarily maintained by OpenIcc and what work is in progress?

Compiling Smalltalk to fast native Code

The Lua scripting language has been designed to be embedded into software written in C to allow for scripting and extending of such software. Lua is popular because it is easy to integrate and the language itself is simple and easy to learn. The compact code size and small memory footprint make it a candidate for embedded use. Most Lua use cases are to extend end-user software, like e.g. the popular game "World of Warcraft" or the photo editing and archiving software "Adobe Lightroom". In this presentation, however, the author will show how Lua can be used in an operating system kernel. An actual implementation will be presented based on the NetBSD Unix-like open source operating system.

Demonstration of building applications with the Adhearsion voice application development framework.

Many open source hackers see the allure of building applications that integrate with the telephone network. However layers of industry jargon, proprietary technology and arcane knowledge lead many to believe that telephony is "hard." Adhearsion will change their minds. The Adhearsion project is an open source voice application development framework, the first of its kind in the open source world. In this talk we will build several working voice applications and demonstrate how to integrate them with existing PBX installations. Along the way, we will discuss voice application design and show how to avoid common pitfalls.

Interchange is an Open Source e-commerce software written before the advent of any modern Perl. Thus we implemented a lot of things like running a server, dispatching, parameter parsing, session handling and templating. We decided to reduce the source code drastically by using modules from CPAN like Dancer, PSGI and Template::Flute instead of our own custom code.

Interchange will become a collection of a few base modules providing an API for carts, payment, shipping and access control which can be extended easily with plugins. This provides you with a solid, fast, simple and flexible platform for your online business based on modern Perl, which is going to be demonstrated during the presentation.

We can't get anywhere with free software if the developers don't do design. They always did. It just sucked because they went with whatever the first iteration was. The focal point changed and "we'll add some UI later" is not design. Interaction with the software is key. Design requires you to have a general idea about the interaction upfront, but not everything. Once a general idea is out there an agreed upon, the second part of the design process kicks in. "Prototyping" Prototypes help you see the flaws of a design more clearly, and missing features can be added to accelerate the design/development of the project. Frequent and agile iterations between visual designing & prototyping is part of a healthy design process. Since developers can write code they can also prototype, (as long as they don't get attached to their code). This talk is about how designers tricked a developer to be one of them...

In many production systems, indexes are designed empirically and without instrumentation to check their efficiency, resulting in poor performance and increased hardware needs. Learn in this talk the fundamental ideas behind indexing, the errors you should avoid and the tools that can help you harness the full power of indexes. The following topics will be covered: - strengths and limitations of indexes in MySQL - performance degradation caused by bad indexes - guidelines to design efficient indexes - tools and methods to identify and remove unnecessary indexes.

Spoon? Spoon! It's a minimal object programming system derived from Squeak, with new approaches to organization, collaboration, and deployment. Spoon is the system I want for writing and distributing software. Initially, it has only that needed for a new programmer to start and extend it easily. This includes a module system, with which any Spoon system may provide code and data to others. Each module is a live object, and coordinates the direct synchronization of providing and consuming systems. The very smallest object memory snapshot I've made is 1,337 bytes long. An interesting intermediate result of this work has been "session imprinting", the transfer of compiled methods directly from one system to another as a side-effect of running them, without needing to compile source code.

Battle for Wesnoth has a reputation for being a balanced game, but it took many years to get there. This was a long learning process, not only to get a balanced game, but also to learn how to use the resources available specifically to open source software and use them in the best possible way to reach a game that is challenging without being impossible and fair to all players.

The AFUL, a French non-profit organization, has launched a contest called AFULTab to challenge developers to propose a FOSS tablet environment with the hardware of their choice. NetBSD enthusiast and DeforaOS developer is currently working on his own proposal, both adapting NetBSD for tablet hardware and polishing the user interface from the DeforaOS desktop environment. This talk will summarize the work done, in progress and planned before the official release date on May 1st.

Cypher is a declarative query language recently added to the Neo4j graph database. In this talk we explain the motivations for creating this language, describe its current features and design, and dive a little into its implementation. Finally, we discuss the future direction of how we expect the language to evolve.

A lot of the things in software engineering we take for granted these days are rooted in Smalltalk. But most people do not program in Smalltalk. Do you wonder if there are more pieces of brilliance in Smalltalk waiting to be picked up by the general computing community? Come and experience yourself. We'll work with you through an exercise showing Seaside, Glamour and other little known treasures, fully exploiting the 'objects-all-the-way' attitude visible in the Pharo open source Smalltalk environment. Bring your laptop to pair through the exercises. Take home a web application, deployed on your laptop.

Clarissa would like to convince "geeks" that they need "normal people". She wants to convince geeks about what an Average Jane or Joe can bring to FLOSS, because she wants geeks to make some efforts to welcome them.

Indeed, it has been quite difficult for her to enter the community. Difficult, but not impossible! And now, she simply loves FLOSS. So she'd like to explain how Mozillians managed to catch her attention. And which kind of contributions geeks can propose to "normal people" to attract them, and to keep them in the community... You'll see that Average Jane or Joe can be useful ;-) She thinks geeks need Average Jane or Joe to understand what the public really wants or needs. It's the only way to really open up the Web! So throughout this talk, she will explain what you can do to attract "normal people".

The talk will be a summary of the motivation and problem encountered while setting a global shared account database for the Mageia distribution infrastructure, focusing on LDAP and the issues around software integration, patches and directory synchronisation.

There are tons of virtualization projects based on tracing: user-mode linux, umview/kmview, fakeroot-ng, cde. Ptrace is ugly and old but fundamentals tools rely on it: gdb, strace. New tracing facilities like uprobes, lttng and systemtap have been designed mainly (only) for debugging, not for virtualization. In the meanwhile there are new efforts to create more flexible kernels: anykernels and millikernels. These new approaches need a specific support: hooks, hypercall or tracing. It does not matter how we call it. Utrace is (was) an option, with some minor effort at kernel level, even classic ptrace could be implemented at user level for back compatibility. The workshop wants to be a technologically agnostic discussion on tracing supports for virtualization and for new flexible kernels. All contributors of new ideas are welcome to the open discussion.

Many of the MySQL servers now support inspection of the InnoDB buffer pool contents. Since effective usage of the InnoDB buffer pool is critical to good MySQL performance, a look into what is in your buffer pool is an effective tool to optimize your table layout and index usage for optimal performance. The presentation shows how to use this information to create efficient tables and indexes by looking at your buffer pool contents.

Presenting tools and workflows used via Open Build Service by various distributions to develop the distribution. This includes automated source processing, validation, QA, automated and manual reviews. Additional focus point on maintenance handling, means updates after a distribution is released which are usually done in a complete different way. I like to have a discussion about the question how distributions should validate trustable sources and how the trust can be increased by a common distro effort.

An overview of what the Firefox Mobile team has been working on and the future plans for Fennec.

In this talk, I'll use my unique experience from both the standpoint of a system administrator in a small company as well as a reasonably successful DevOps tool writer to explain how modern tools can be used gradually to transition a business to welcome more DevOps practices without sacrificing stability or productivity and in fact increasing both!

Many still consider and talk about DevOps as an absolute thing: developers and operations are the same thing. Of course, this is not the case. DevOps is a range, where on the far left we have old-style ops (very exclusive) and on the far right we have developers doing all the ops (very inclusive). The idea of DevOps itself is only possible due to wide variety of tools which have become available: Chef, Puppet, MCollective, Vagrant, Cucumber-Chef etc. Prior to these tools, developers simply couldn't be expected or trusted to hook up a terminal to a production machine and run scripts. But with these tools in hand, the ops team can now setup an environment where we slowly push the bar from extreme exclusivity towards more inclusivity. In this talk, I'll use my unique experience from both the standpoint of a system administrator in a small company as well as a reasonably successful DevOps tool writer to explain how modern tools can be used gradually to transition a business to welcome more DevOps practices without sacrificing stability or productivity and in fact increasing both! Specifically I'll talk about: How metrics and monitoring can make the Ops world more transparent, starting the process of bringing in developers. How development environments provisioned with production scripts and the ability to test new scripts can allow developers to experiment with Ops. How building a test infrastructure for testing automation scripts can maintain stability in your organization while allowing people unfamiliar with the ops world to get involved. The importance of dedicating "office hours" as an ops engineer to teaching developers. "Who wears the pager?" or transitioning pager duty to other engineers safely by leveraging the above tools. This talk is based on my experience as: Engineer on Vagrant which powers many large companies and has helped many companies move towards a more DevOps-friendly attitide. I've seen first-hand how tools can assist this transition. System administrator and software engineer at Kiip, a small company with around 20 employees. I'm the only engineer with any Ops experience, and I've had to very slowly transition our company towards being more Ops friendly.

The European Parliament Free Software User Group (EPFSUG) is currently a 37 person strong user group of staff, assistants, MEPs and supporters from the free software community. The mission of EPFSUG is to * Assist people interested in using free software in the European Parliament * Drive adoption of free software in the European Parliament's information infrastructure * Push for use of open standards, to ensure equal access for citizens using free software * Work in cooperation with like-minded groups in Europe and around the world This Lightning Talk will make you want to become a supporter too, because everybody needs a hacker to talk to sometimes, in particular the folks who work in the European Parliament!

The first public announcement of the European Parliament Free Software User Group (EPFSUG) on 6 February 2010 was made at FOSDEM. Now one year later EPFSUG wants to come back and tell the world what happened, what we do now, and what our plans are. We currently constitute 1 patron, 11 members and 25 supporters. We have a website, some mailing lists and a pad. EPFSUG is a user group, but it's complicated. Most members have standard EP office workstations with very little free software running. At the same time, most of EPFSUG's supporters are hackers and overall very proficient free software users. We try to bridge the gap application by application. Our first project for opening up the possibility to use free software in the European Parliament is tmail - a server workaround to let you use your mail with IMAP - and with it new simple ways to have basic email privacy. Our second application is the browser. So far not much has happened in practice on the EP office workstations, but we have at least initiated a dialogue with the EP folks who really decide, and it looks like Firefox will soon be available on the standard EP office workstation. The third big project will of course be word processing, but we have not worked so much on that yet. We also come together to talk about free software in society at large (ie. the world outside the EP) so we have had meetings on FreedomBox, ParlTrack, Ubuntu Unity and CiviCRM. The most ambitious presentation so far was probably a hacker perspective on reverse engineering the law making process... EPFSUG could grow much more. We want to come to FOSDEM again for the same reason as last year - "The EU Parliament needs your help" - but this time we'll maybe have a stand with t-shirts and stickers, and a looong to-do-list with stuff to hack :-)

The Enlightenment Foundation Libraries is a UI toolkit designed for the embeded world in mind. We have now released version 1.1 after almost one year of work. This new version come with new features, a lot of speed and memory improvement, improved portability (we officially support Windows now) and no API or ABI break. It is a proof of the will of Enlightenment team to provide a reliable base for any serious work. We are now working on preparing a release for another set of important libraries and also finishing the last few items in the Enlightenment DR 17 todo list. With Tizen project and the growing contribution of Samsung, 2012 is going to be a very interesting year for the Enlightenment project and we will talk about just that.

Gervill is a MIDI Synthesizer which supports digital instruments like SoundFonts and DLS (Downloadable Sounds). The audio processing code in the project has many other uses beyond MIDI, for example as a sound effects engine in games. In order to further evolve the project the plan is to seperate the audio processing code from the MIDI engine. This talk will be about the internal of Gervill audio synthesis, some of the problems in there and how we are going to improve upon them in mind to make it easer to extend and separate the engine. At the and of talk there will demostration on how Gervill can be used for real-life peformance by Teun de Lange.

The University of Strasbourg has built a 'Skype replacement' for ~60,000 users using open source standards and software.

A few years ago the French Ministry of Education and Research, issued a memo that strongly advised against use of Skype in universities and research centers. Security and excessive bandwidth consumption were among the main concerns. In practice however, the directive has been rarely applied for one major reason: (perceived) lack of alternatives. Therefore, in the beginning of 2011, the University of Strasbourg has started an effort that aims to propose an actual Skype alternative to both its faculty and students (~60 000 users). The project started with a number of extensions added to the Jitsi project in order to add support for features such as GTalk interoperability for example. It then continued with a deployment of the actual network using exclusively FLOSS projects such as Openfire, Jinglenodes, FreeSWITCH/Asterisk, TurnServer and others. The talk will also cover aspects such as NAT traversal with ICE and JingleNodes, redundancy, security and confidentiality.

One shiny aspect of the Genode OS framework is its diversity with respect to microkernels and hardware platforms it's running on top of. Although primarily of interest to clients and users, this property provides some hidden benefits to the system-developer itself. This talk is basically an experience report. It will give you an insight into the benefits and troubles of developing on a diverse biotope, the strength and weaknesses of the available platforms, how Genode gets ported to a kernel, and what is basically necessary from the kernel's perspective to drive Genode. The last point will be illustrated by introducing recent developments of a hybrid kernel/user API in Genode.

Deploying from Git `git-deploy`, a tool to make rollouts and reverts easy, and the sort of development culture at Booking.com required to use the tool effectively, such as the the role of monitoring and testing.

Booking.com has recently open-sourced its internal development tool, git-deploy. Since its internal introduction in 2008 it has allowed developers and web designers to put code live in a simple and easy procedure, enabling them to roll code out into production within seconds of it being pushed to the master repository. This talk covers the rollout framework, the tool itself and its internal workings, including per-subsystem tag creation and ability to stage changes before rollout and rapidly roll back, create hot fixes, automated rollout emails, change tracking, rollout history etc. We will also discuss the necessary development culture required to use the tool effectively, such as the the role of monitoring and testing.

The world's oldest free office suite, now under its new name Calligra, is deployed over many different devices. It's engine is used in various places, and greatly varying applications throughout the world. Come and see what we do, and witness, perhaps, some things you didn't know it did, and places you had no idea it would be found.

pkgsrc is a collection of over 11,000 packages available for a variety of operating systems, developed by the NetBSD project. Since the end of 2010, there is an ongoing effort to port pkgsrc to MirOS BSD, an operating system derived from OpenBSD. This talk gives a short overview over pkgsrc, comparing its usage and features to MirPorts, the older "native" packages system on MirOS. Compared to MirPorts, pkgsrc has many more and newer packages, a more active community of developers and a very responsive security team that identifies and patches vulnerable packages. Some more practical aspects will also be treated: how to get a new platform supported in pkgsrc (both on the technical and on the administrative side) and which are the principal challenges in doing so.

The GNU FM software allows music lovers to share their listening habits and to discover new music. It allows artists to find new audiences for their music and to earn a little money. Libre.fm is a public installation of GNU FM which anyone can make use of, and which currently has roughly 50,000 users and over 80,000 streamable tracks by 7,500 artists. By letting Libre.fm know what music you like and dislike it's able to construct personalised radio streams filled with great freely licensed music tailored specifically to your tastes. In this talk we'll discuss what we've achieved so far, our plans for the future and how you can help out.

GNU FM implements the Last.fm protocols, making it an easy drop-in replacement for clients that already support the submission of listening statistics to Last.fm, and for clients capable of playing Last.fm radio streams. A number of players have already added out of the box support for Libre.fm, including the GNOME music player Rhythmbox.

Mozilla supports one of the most diverse and varied sets of machines in the industry. Some sets must serve tens of millions requests per day, and some must perform complicated and intensive functions. Some of their greatest assets are external code contributions and community involvement. Come see how many of the projects within Mozilla IT have been open sourced, and how external contributors have improved the projects.

IcedRobot is an attempt to bring the Android API on OpenJDK. It was first announced at Fosdem 2011, and after only two months of development and a team assembled during the customary Fosdem Free Java Hackers dinner, it was already able to translate most Android bytecode format to Java. This presentation will review the last year of development and will explain future direction and plans for the project.

Learn how to set up and use Ogre3d to provide a powerful and extensible 3d graphical engine. The focus is on explaining the core concepts and objects needed to get rendering up and running, as well as how to integrate the graphical engine with a game.

Problem: you want to test many different builds of MySQL. There is a proliferation of MySQL versions and builds. Working as a DBA or as a consultant, you will find large installations of MySQL 5.0 to 5.5, with subtle variations among them. In the same company there may several versions of MySQL 5.1, or you may find a mix of vanilla MySQL and Percona or MariaDB builds. For all these version, you often need to reproduce a problem using the same version being used in production, and often you need to install several test servers in the same host for this purpose. Then there are the work-in-progress versions that Oracle and other companies are producing. And you want to test them before adopting them. For all the above needs, there is MySQL Sandbox, a versatile tool that allows you to install multiple servers in the same host, no matter if they are the same version or different ones. This workshop will explain quickly how MySQL Sandbox works, and then show with practical examples how to test several combinations of servers in a single host quickly and painlessly. It will also show examples of how to use MySQL Sandbox to solve practical administration tasks, such as re-playing binary logs or producing a filtered binlog.

Netmagis is a network management tool not unlike Netdot but with some original features

* Host and network management : Netmagis features host and network declaration, DNS and DHCP generation. Netmagis shows an interactive address MAP allowing to see free addresses. It also supports IPv6 addresses. * Network Metrology : Netmagis is a complete plateform which also integrates network equipement polling via SNMP to generate automatically RRD trafic graphs * Network Configuration and Topology and network equipement configuration collection (with rancid) and analysis to build a graph. From the graph, network maps are derived allowing vizualization of the topology. * Network modifications : the topology module includes a web interface which the network operator to change the VLAN on an interface of an equipement. * MAC address association : the polling system also polls equipements regularly to store IP-MAC association and MAC-PORT-VLAN association into a database to track and localize hosts. * Rights management and delegation : netmagis also possesses a detailed right models allowing delegation of several network management functions. * License :Netmagis uses a BSD license

Ontological Conjunctive Query Answering knows today a renewed interest in knowledge systems that allow for expressive inferences. Most notably in the Semantic Web domain, this problem is known as Ontology-Based Data Access. The problem consists in, given a knowledge base with some factual knowledge (very often a relational database) and universal knowledge (ontology), to check if there is an answer to a conjunctive query in the knowledge base. This problem has been successfully studied in the past, however the emergence of large and semi-structured knowledge bases and the increasing interest on non-relational databases have slightly changed its nature. This presentation will highlight the following aspects. First, we introduce the problem and the manner we have chosen to address it. We then discuss how the size of the knowledge base impacts our approach. In a second time, we introduce the ALASKA platform, a framework for performing knowledge representation & reasoning operations over heterogeneously stored data. Finally we present preliminary results obtained by comparing efficiency of existing storage systems when storing knowledge bases of different sizes on disk and future implications.

With SIP networks being used for more than just Voice/Video calls, it has become important that the SIP infrastructure provide secure signaling channels; this talk will present features of Kamailio and how they can be used to provide this security.

Besides quick update of what is new lately in Kamailio SIP Server project, the presentation will focus on showing how to use Kamailio to build a secure communication platform for SIP. Kamailio features a scalable SIP routing engine for dispatching of Voice/Video calls and Instant Messages as well as rich SIMPLE presence server for user availability states with embedded XCAP server for management of privacy rules and buddy list. With IM and Presence traffic being carried via signaling channel, encrypting SIP channel is the only way of ensuring confidentiality and protection of data exchanged. Today, Kamailio offers asynchronous TLS communication layer, tested and improved over last years for robustness and cope with the demands of telecom-grade deployments.

pkgsrc is a cross systems packaging system, used in NetBSD, but also DragonflyBSD, MirBSD, Minix3 and a lot more. Through the example of shotwell, a digital pictures management application, this talk will give an introduction to pkgsrc for users and packagers.

"POSIX" stands for "Portable Operating System Interface". The POSIX module in "Perl core" is ancient, full of quirks and historical mistakes. However, for that same reason, it will not get fixed. The new "POSIX::1003" (living on CPAN) tries to be an alternative: same functionality (and more), more consistent, and documented by function group.

The libvirt library provides a hypervisor agnostic API for interacting with & managing virtualization hosts. Traditional uses of virtualization have focused on running entire operating systems in virtual machines or containers. The libvirt-sandbox library builds on libvirt, LXC & KVM, providing an API which facilitates the use of virtualization as a tool for building secure application sandboxes, without the additional burden of maintaining additional OS installations.

More and more distributions are porting their software to run on ARM CPUs. This is a session for people working on or otherwise interested in those ports to share progress reports, problems and ideas. Steve will start the discussion with the current status of the two ARM ports in Debian ("armel" and "armhf"), but is not planning on spending the whole session on that!

Taxi DB is designed to store ICC device profiles and meta data online. What technology is used and how it works will be in the talk.

In the form of XULRunner, the Mozilla Platform can be used as framework to develop powerful applications. This talk looks at how XULRunner together with the Mozilla XForms extension has been used by a university hospital to build a powerful medical documentation system. A special look will be given to the changes over the years and how the Rapid Release Process influenced the way the application and the XForms extension are developed.

Mail2trac, a Trac plug-in, presents a new interface allowing Trac users to interact with it by email.

Trac is a free, web-based project management and bug-tracking tool. It is written in the Python programming language. Until mid-2005, it was available under the GNU General Public License; since version 0.9, it has been released under a modified BSD license. Fast, highly flexible, its users can configure a lot of thing, and extend its functionalities with dozens of plug-ins. Mail2trac is one of them. The main purpose of mail2trac is to present a new interface of extension allowing trac's admins to propose to their users to interact with trac using mail. In this early version, it already propose this interface, and allow to create and respond to tickets via email. Let us show you mail2trac, its work-flow and its future.

A reliable and transparent, high volume package review infrastructure was implemented with the [Open Build Service (OBS)](http://openbuildservice.org/). In OBS, a software package can travel through several projects. Submission Review is done at project specific gates to control such travel. The openSUSE:Factory project currently defines review gates for license compliance, security and packaging. Together with an issue tracking system we create a community friendly ecosystem that implements project policies. Centralized gatekeepers or dedicated review periods are eliminated. Propagation delay is minimized. With OBS providing the hooks to add review authorities, we were able to code most of the respective business logic with python scripts, reusing and extending the osc command line tool as a feature-rich layer ontop of the OBS API. This talk describes the openSUSE project review process and how it helps various stakeholders to excercise their control, using the legal team as a non-trivial example.

PMH is a home automation system built from the ground up to be easy to use, modular and as open as possible. Our software and hardware are completely open source, with source code, schematics and CAD files available online. PMH consists of 3 layers. The hardware layer, the überdust layer and the apps. In the hardware layer, we use a wireless sensor network with sensor nodes and actuators that communicate with each other using the low-power IEEE 802.15.4 protocol and with a computer that acts as the main controller. The wireless sensor network consists mostly of Arduino nodes which control lighting, heating/air conditioning and electrical devices while at the same time using sensors to measure things like power consumption, temperature, light, movement, air quality etc. Überdust is responsible to bridge the other two layers by capturing and saving the data from the WSN to a central database, and provide easy to use interfaces (i.e. REST, Web Sockets) to the application layer. This way, applications can get sensor values from the wireless sensor nodes, and control the nodes accordingly. In the application layer, we have developed a web and smartphone application that gives users the ability to remotely control the system, view the current status of the various sensors and set automated behaviors such as turning on the lights when there are people in the room, sending a notification to the user's smartphone when someone enters your room, turning on the water boiler on predefined times, etc. Last but not least, due to the modular and open source nature of our system, its easy to add additional data providers in the hardware layer, such as an arduino with additional sensors, or even your computer and smartphone (i.e. your smartphone's accelerometer, the status of your server). It's just as easy to develop your own apps using our APIs, and extend the capabilities of the system to meet your own needs (remote controlled BBQ anyone?)

In the talk we will talk about WebKitGTK+ [1] current status and work done in the last months since last desktop summit. A lot of things have happened in these months, we will summarize the various WebKitGTK+ improvements in rendering (accelerated compositing), accessibility, networking, etc. Also we will cover WebKit2 architecture and initial version of the API, we will detail the roadmap for WebKit2 support for WebKitGTK+. And or course some nice demos :). The talk should be interesting for embedders and those considering integration of the web with the free desktop

This talk considers the two most common user stories for OpenNMS integration with modern, conventions-centric configuration management platforms.

As organizations of all sizes provision and run servers at larger scale and in ever more agile ways, the platforms used to monitor and manage those servers' performance often become a liability. The best-known free software tools in this space tend to make compromises between scalability and ease of automation, while proprietary platforms are prohibitively expensive and inflexible. Enter OpenNMS, the world's first enterprise-grade network management application platform that is fully free software. Massive scalability has always been the principal design goal of OpenNMS, and recent feature additions including a dynamic provisioning subsystem and ReST API offer a path for easy integration with modern, conventions-centric configuration management platforms. This talk considers the two commonest user stories for such integration, from concept through working code. Organizations already on the DevOps train almost certainly use a modern configuration management platform, such as Puppet or Chef, to provision and run their physical servers and cloud machine instances. For this use case, it makes sense for the configuration management platform to act as the “driver” for the systems management platform. To service users in this situation, we will explore what it takes to build a working integration where OpenNMS automatically takes its service-assurance and performance-management orders from Puppet. Of course, plenty of organizations are still running alongside the train, just starting to move server provisioning and configuration management to an automation platform. Since we want to leave nobody behind, we will also evaluate the approach of using the work already put into populating an OpenNMS instance to help bring configuration management religion to all those lovingly hand-built servers. The development part in this talk will show which steps are necessary to create your own provisioning adapter in OpenNMS. As a practical example we will show how you can create a Puppet URL handler and a Puppet provisioning adapter. With this adapter it is possible to pull node information from a Puppet master into OpenNMS. If you want to have Puppet as your master database for nodes, we will give examples how is it possible to use the OpenNMS ReST API to push nodes from a Puppet master into OpenNMS.

The year 2011 saw a lot of work being done on replication in MySQL world. Different implementations of the same feature were produced, compared, and put into releases. This talk present an easy-to-understand summary of the results: - What exactly are the new features - Where they have/will be released - What are the differences between implementations in various MySQL branches We will also discuss how the new improvements relate to alternative replication solutions like Galera or Tungsten.

Implementing support for device drivers (device driver frameworks) in a microkernel-based/multiserver operating system presents some unique challenges. In this talk we will go through all the important aspects of device drivers in HelenOS, at the hurdles and the ways they can be overcome. We will discuss topics such as: - Programmed I/O and DMA in user space - Level interrupt handling and interrupt clearing, tasklets - Cooperation of user-space drivers and kernel (debugging) drivers - DDF and Device Manager - automatic driver start, device enumeration and hot (un)plug - Exposing driver services, Location Service - drivers are not created more equal than others, a.k.a Death of the Pseudo Device

OpenRemote is an open source project operating in the field of Domotics. OpenRemote develops and distributes a standard based platform that is extensible and flexible with applications to Home Automation, Energy Management and Healthcare. This community based project integrates varied field protocols (such as KXN, X10 and Z-Wave) in a common framework and allows for easy creation of visual panels. Open Remote supports the leading standard platforms iOS, Android and web. OpenRemote offers a variety of cloud-based tools which are aimed at simplifying the work of professionals as well as hobbyists.

After a quick business introduction, covering the business model, the raison d'etre for a standards based, open source platform in the crowded field of home automation, this presentation will address: - the global architecture of the OpenRemote ecosystem and its components - a detail presentation of each components, their role and the technologies used - a short video of the great applications the community has used OpenRemote for - a technical walk-through of the how to implement a new protocol - the OpenRemote community

Visualizing a directed property graph with Processing.js and Neo4j. A short introduction to Processing.js, followed by a high level overview of an example visualization and finally how to connect it to Neo4j via their REST API to populate it. Example: http://getvouched.com/visualizations

Building computer games is fast becoming big business, not just for the big companies, but also for the little companies. To join this vibrant world, we need tools: Ways of easily constructing the games, modern and effective distribution methods, ways of getting the users' feedback and so on. Enter the GamingFreedom.org project, whose open platform empowers everybody to create and distribute games. This talk will shortly explain the ideas behind GamingFreedom.org, and present the Gluon framework for creating games, and the GamingFreedom.org network for makers and players of games. Finally: A live, on-stage demo!

The Colour Management System exists since 2004 with a long history of new ideas for Linux ICC style Colour Management. Find out what it does and what is hot.

pkgin is aimed at being an /apt / yum/ like tool for managing pkgsrc binary packages. Many so-called GNU/Linux distributions provide a convenient way of searching, installing and upgrading software by using binary archives found on "repositories". NetBSD, and more widely, all operating systems relying on pkgsrc have tools like pkg_add and pkg_delete, but those are unable to correctly handle binary upgrades, and sometimes even installation itself. This is the purpose of /pkgin/, to provide the user a convenient way to handle binary packages, using the same working mechanisms than tools like /apt-get/.

If you are using the default Java/Java plug-in on a major Linux distribution, chances are, you are using IcedTea and IcedTea-Web. This talk will focus on those projects. It will cover what IcedTea and IcedTea-Web are, the many improvements have gone in over the past year, and where the two projects are headed over the next year. In short: * Want to know what IcedTea/IcedTea-Web are? Come to this talk! * Wondering what we did over the past year? Come to this talk! * Wondering where IcedTea/IcedTea-Web are headed? Come to this talk! * Don't care about Java and want to fall asleep? Come to this talk! Well maybe not the last one, but you will leave satisfied about #s 1, 2 and 3 :)

Let's have a look at the why and how of virtualization and see how it impacts applications with a big hunger for resources. We will run through the different layers of a virtualized environment and examine their impact. Can we tune MySQL to be better adapted to a virtual environment?

Mozilla looks forward to grow both in scope of projects, back-end technologies and languages in 2012. Chris and the l10n team are going to give a sneek peak on how they'll make existing tasks easier and answer new challenges this year.

SIP can be used for much more than 'plain phone calls', and this talk will demonstrate chat, file transfer, contact lists and more!

PSTN emulation and audio calls are by far the most used applications for VoIP and SIP these days. As our communication needs grow we are in need for new means of communication, however. Why use the phone to do VoIP, email to send files and jabber to have a chat channel in the context is a single conversation? We can merge those 3 communication channels within the same call with SIP today. In order to find the perfect moment for the conversation presence may be used and policies for presence together with our own contact list may be stored in a remote server and synced with all of our devices. All this can be done today, with SIP, in a standard way and with Open Source tools.

We are recently witnesses of the significant movement and adoption of NoSQL databases. In particular, the graph databases become an important technology as we deal with a high increase of relational data. They not only store graph data structures much more efficiently, but also provide powerful graph traversal capabilities that make them suitable for this kind of data. However we need to ease the exploration and understanding of these large amount of data. Visualizing the graph structure (relationships between nodes and edges) is critical to many situations like: verifying the reliability of new data input, optimizing an architecture based on the shape of the data, and even creating new services based on facts discovered in the data. In this talk, you will learn how to understand the graph structure easily using Gephi & Neo4j! We will go through the installation and showcase of visualization capabilities of Neo4j graph database in Gephi. The talk will cover exploration of general useful features of Gephi applying them on imported Neo4j database.

This talk gives an overview of what git-annex is, how to use it, and why.

Talking points: * What is git annex * What is the need/use-case for git-annex * How does git-annex store data outside of git, yet integrate seamlessly with git * What backends can git-annex use for storage? * What are common use cases? There are a lot of ways to use git-annex. * Short demonstration or time for questions.

* Where to start as a novice * Mentoring programmes (Google Summer of Code and Code-In, Outreach Program for Women, GNOME Love) for those who want to commit to a longer-term involvement * Guest appearance by Ekaterina Gerasimova to talk about the Outreach Program for Women, and her experience as both an intern and mentor in the GNOME Documentation Project * GNOME-specific entry routes, both through GNOME technology and GNOME Foundation initiatives * Becoming a module maintainer, the responsibilities and benefits * Examples of the above topics , with specific references to the Vinagre, Vino and Cheese projects, which I maintain * Alternative ways to contribute to GNOME, such as translation or volunteering to help organise GNOME events

FusionInventory is an IT asset inventory solution. The project has two components: the server, a PHP plugin for GLPI and the agent, a Perl program.

The agent is responsible for executing various tasks implemented as plugins, such as local inventory, network discovery, software execution, etc. Its design, resulting from the aggregation of multiple unrelated pieces of software, was quite... baroque. This talk will present the challenge of joining an already existing project, with a legacy code base, and turning it to modern Perl best practices.

Discussion about features of the next Java SE Platform, JDK 8.

Geeklog is a web content management system. The project has been around for more than 10 years now and is probably best known for powering the Groklaw website.

Yet another CMS? Actually, Geeklog has been around for longer than many of the other systems, yet has kept a low profile. Originally written for a security portal, security has always been our focus - to the extent of refusing certain features as long as they can not be implemented in a way that we consider secure. The lightning talk will provide a quick overview of Geeklog, its features, focus, and community.

Debian is usually advertised as a volunteer project with a subtle mix of democracy and do-ocracy. While this is correct, implementation details are mostly undocumented, and it is often difficult for prospective or relatively new contributors to really understand the inner workings of the project. This talk will detail some useful lessons, and also some secrets about Debian learned over the years. It is hoped that it will be helpful to people willing to get things done in Debian.

Recent developments in the Xen community mean that installing and configuring a Xen host has never been easier. However Xen remains both powerful and complex which can prevent a barrier to those wishing to deploy Xen. In this panel discussion we will briefly present recent user facing changes to the way in which Xen is deployed (e.g. xend to xl toolstack migration, Project Kronos, pvops Linux kernel domain 0 support). The bulk of the session will be an opportunity for users to describe problems which they are having deploying Xen and discuss the solution and possible future directions with a panel of Xen developers.

Graph databases are one of the leading drivers in the emerging, highly heterogeneous landscape of database management systems for non-relational data management and processing. The recent interest and success of graph databases arises mainly from the growing interest in social media analysis and the exploration and mining of relationships in social media data. However, with a graph-based model as a very flexible underlying data model, a graph database can serve a large variety of scenarios from different domains such as travel planning, supply chain management and package routing.

During the past months, many vendors have designed and implemented solutions to satisfy the need to efficiently store, manage and query graph data. However, the solutions are very diverse in terms of the supported graph data model, supported query languages, and APIs. With a growing number of vendors offering graph processing and graph management functionality, there is also an increased need to compare the solutions on a functional level as well as on a performance level with the help of benchmarks. Graph database benchmarking is a challenging task. Already existing graph database benchmarks are limited in their functionality and portability to different graph-based data models and different application domains. Existing benchmarks and the supported workloads are typically based on a proprietary query language and on a specific graph-based data model derived from the mathematical notion of a graph. The variety and lack of standardization with respect to the logical representation of graph data and the retrieval of graph data make it hard to define a portable graph database benchmark. In this talk, we present a proposal and design guideline for a graph database benchmark. Typically, a database benchmark consists of a synthetically generated data set of varying size and varying characteristics and a workload driver. In order to generate graph data sets, we present parameters from graph theory, which influence the characteristics of the generated graph data set. Following, the workload driver issues a set of queries against a well-defined interface of the graph database and gathers relevant performance numbers. We propose a set of performance measures to determine the response time behavior on different workloads and also initial suggestions for typical workloads in graph data scenarios. Our main objective of this session is to open the discussion on graph database benchmarking. We believe that there is a need for a common understanding of different workloads for graph processing from different domains and the definition of a common subset of core graph functionality in order to provide a general-purpose graph database benchmark. We encourage vendors to participate and to contribute with their domain-dependent knowledge and to define a graph database benchmark proposal.

Percona Toolkit is an indispensable set of opensource command-line tools for managing and administering MySQL servers. This session will introduce the toolkit and the available tools, then demonstrate how to use some of the tools to manage replication, analyze queries, perform common DBA tasks, analyze disk I/O usage, and more.

SVG 1.1 is now widely implemented, and has some (minimal, optional) support for ICC colours. In the main though it is an sRGB system. SVG2 adds a conformance class for full ICC support (v2 and v4) including named colours, direct specification in LAB or LCHab, and interpolation in LAB or LCHab. Unmanaged device-specific colour is also supported.

With binary package management tools such as pkgin or nih, building sets of packages and maintaining a repository becomes a need, mostly when managing multiple servers. This talk presents the setup of different bulk build solutions in pkgsrc.

Panel discussion on various topics with authors of several microkernel / multiserver operating systems.

RPM is a well understood and relatively easy packaging format that helps to deploy sets of files in a consistent, reproducible and reversible way, and YADT enables organizations to describe their system landscape in a simple, human readable YAML format.

RPM is a well understood and relatively easy packaging format that helps to deploy sets of files in a consistent, reproducible and reversible way. Tools like yum, zypper and apt have enabled admins to install, remove and update complete dependency chains of RPMs and to verify on-system changes to these file sets. Which seems to be a perfect starting point for doing general configuration management with those tools: larger dependency chains can be pulled in via a simple RPM, configuration files can be delivered inside RPMs, administrators feel right at home and have their toolset for installing, updating and verifying the configuration on the machines, developers can easily contribute to simple packaging. Part I of this talk describes how (and why) we do this at Immobilienscout24.de and discusses pro and cons of this approach. Part II builds on this and describes our next generation data center deployment and management tool, YADT. YADT enables organizations to describe their system landscape in a simple, human readable YAML format. YADT is fully aware of not only dependencies between packages and configs, but also of interservice dependencies. Due to this, YADT makes sure that the systems within your platform are updated, configured and restarted in the correct order. It does this by analyzing service and package dependencies and by grouping dependent systems into "chunks". Deployment then happens as a sequential wave over those chunks, making sure that the platform stays online during the deployment. YADT is in the process of being open sourced and is available at https://code.google.com/p/yadt/

Is your Android code easy to write, to read and to maintain? AndroidAnnotations is an Open Source Android framework that aims at simplifying your Android developments, without performance cost. AndroidAnnotations helps you build Android Applications faster because it allows you to focus on your business problem rather than the plumbing code that connects components and systems. Simply put, AndroidAnnotations generates the boring boilerplate code of your application at compile time, using the Java 6 Annotation Processing API. The presentation will start by explaining the key concepts, followed by a live coding of a simple Android application, to demonstrate AndroidAnnotations' advantages.

In this talk Rob will highlight the key technologies and events that are going to affect open Web game development in the near future. He will also demo some of these new technologies and show how easy it is to share your game and make money from it using the open and distributed Mozilla Labs Apps project.

Mozilla is building a generation of webmakers — people who do not consume the web, but help make it. To do this, we're teaming developers up with journalists, filmmakers, and kids around programs that show you how to bend and hack the web. We need your help to reach more people and build tools that expose the power of the web. Come learn more!

A round-table discussion about VoIP and related topics with the day's speakers.

What is Semantic MediaWiki, what can it do for me, and why is it not on Wikipedia yet?

Semantic MediaWiki (SMW) is a free, open-source extension to MediaWiki – the wiki software that powers Wikipedia – that lets you store and query data within the wiki's pages. Semantic MediaWiki is also a full-fledged framework, in conjunction with many spinoff extensions, that can turn a wiki into a powerful and flexible “collaborative database”. All data created within SMW can easily be published via the Semantic Web, allowing other systems to use this data seamlessly.

2dehands/2ememain uses Memcached for caching Moose objects. We use MooseX::Storage for this, and have extended it in some interesting ways.

We deal with issues such as: * We cannot flush the cache, so we need an upgrade path for new object versions. * We wanted to isolate some changes that are normaly global settings. In this talk Marius will describe how they use Moose with Memcached and show how they used the standard Moose/MOP tools to extend MooseX::Storage to support their needs.

In this talk we'll see how web applications are being integrated into the new GNOME 3 experience. We'll cover both the current status of the specifications and its support in GNOME 3.2 through the Epiphany application mode and the new developments in the multiple emerging standards (Mozilla OpenWebApps, Chrome applications, WAC applications, W3C widgets, etc) and how we plan to support them in future versions of GNOME.

In this session you'll learn how to choose hardware that helps MySQL execute queries the most quickly, while providing the best price-to-performance ratio. This includes choosing and configuring CPUs, RAM, network, and storage systems. We'll also discuss what performance you can expect from various Amazon EC2 instance sizes, including EBS volumes and Amazon's RDS service for MySQL.

A overview and discussion of the existing state of XBL and ways in which we can finally improve it for performance, stability and to make it more flexible, powerful and easier to use. Specifically, we look at the XBL2 specification, some proposals for similar features from Google, as well as other ideas based on the experience developing Firefox.

Open community discussion on the future of Free Java we would like to see.

Unhosted is a non-profit project defining a standard to separate web applications from data storage. The web apps are pure client-side Javascript, fully inspectable and thus enable truly free software on the web. It also allows app developers to enter the web market a lot faster by not needing to care for any data storage. At the same time, users have their data in one place and can use all the apps with just one account and data storage.

Usually, web applications always come with storage attached to it. You can not choose where an app stores the files you use, it’s just their server. Put plainly: You get their app, they get your data. We want to improve the web infrastructure by separating web applications from your data. You have one remote storage where your data and user account resides. In apps, you identify with your user address which then connects to your remote storage and loads your data locally in the app – nothing leaking to the app server. This makes it easier for users because they only need one account and place to have their data – a "My Documents" for the web. App developers don’t need to bother about storing user data or scaling their applications – because it all runs in the user’s web browser. The applications can be Javascript apps using localStorage, like many web apps already. Just include the remoteStorage.js library and search/replace localStorage with remoteStorage – and the app enables people to use their own remote storage for it. To act as a remote storage, a platform needs to provide WebFinger for discovery, OAuth for authorization and Cross-Origin Resource Sharing (CORS) for cross-domain AJAX calls: ownCloud is already compatible and we work on making CouchDB, Wordpress and Google Drive compatible.

Saying proper good bye to our attendees plus with a resume of the sessions with resources, links, videos, etc where you will be able to extend and continue accessing the talks we made after Fosdem.

FreedomBox is a personal server running a free software operating system and free applications, designed to create and preserve personal privacy by providing a secure platform upon which federated social networks can be constructed. Eben Moglen articulated the need for FreedomBox in his 2011 FOSDEM keynote, this presentation is a status update on the work done to turn Eben's vision into reality over the past year. Software for FreedomBox is being assembled by volunteer programmers around the world who believe in Free Software and Free Society, with Bdale coordinating development of a reference implementation on behalf of the non-profit FreedomBox Foundation.

Some closing words, and the not-to-be-missed mythical FOSDEM dance.