FOSDEM 2014

FOSDEM welcome and opening talk.

Welcome to FOSDEM 2014!

Your host will kick off the BSD devroom with a few opening remarks.

Presentation of the Desktops DevRoom by its Organization Team & Technical Committee: Christophe Fergeau (Gnome), Pau Garcia i Quiles (KDE), Didier Roche (Unity), Philippe Caseiro (Englightenment) and Jérome Leclanche (LXDE)

This is a project that already has been in operation for a few months, born about a year ago from Mozilla Hispano, primarily about teaching young children and schools about the dangers out there on the Internet, how to avoid them, privacy in social networks, and others. Webmaker is a preamble (prior to beginning need to know these things). Success Stories of our events in Paraguay (the pioneers) and other countries, with rooms full of people who want to learn.

We will also show webmaker project that seeks to encourage, teach and motivate people of all edadea create anywhere you, through simple and powerful tools that mozilla provides.

A new mocking framework for Pharo. It provides an animation of the interaction between the tested objects.

Common threads run through modern configuration management systems.

This talk will explore CM by examining promise theory, convergent systems, idempotence, and order. We'll also touch on orchestration, immutable systems, and containers, and testing.

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

Ada-Belgium and Ada-Europe are non-profit organizations set up to promote the use of the Ada programming language and related technology, and to disseminate knowledge and experience into academia, research and industry in Belgium and Europe, resp. Ada-Europe has member-organizations, such as Ada-Belgium, in various countries.

More information on this DevRoom is available on the Ada-Belgium web-site.

This talk will take a look at what's been happening in the GStreamer multimedia framework as of late and what shiny new features you can expect to land in the near future.

It is targeted at both application developers and anyone interested in multimedia on the Linux desktop and elsewhere.

GStreamer is a highly versatile plugin-based multimedia framework that caters to a whole range of multimedia needs, whether desktop applications, streaming servers or multimedia middleware; embedded systems, desktops, or server farms. It is also cross-platform and works on Linux, *BSD, Solaris, OS/X, Windows, iOS and Android.

In late 2012 GStreamer 1.0 was released, the next generation of the rather successful GStreamer 0.10.x API series. 1.2 was released just about year later towards the end of 2013 sporting quite a few new features. With 1.4 already in the making and 1.6 on the horizon, we'll take a bird's eye view at what's new and improved and what upcoming new features you can look forward to.

Does hardware-accelerated video playback finally work out of the box on the Linux desktop? Can you get a list of available devices now? Does Blu-ray playback work? How about OpenGL? Will it work on Wayland? Can you use it on the Raspberry Pi?

Join us to find out!

How to develop on FreeNAS.

FreeNAS has been around for several years now but development on it has been by very few people. Even with corporate sponsorship and a team of full time developers, outside interest has been minimal. Not a week goes by when a bug report or feature request is not filed. Documentation on how to develop on FreeNAS simply does not exist. Currently, the only way to come up to speed on FreeNAS development is to obtain the source code, read through it, modify it, and verify it works. The goal of this paper is to create a simple FreeNAS application to demonstrate some of the common methods used when dealing with FreeNAS development, as well as showcase some of the API.

Open and welcome session

How can we enable multiple parties to verify that a binary package has been produced untampered from a given source in a distribution like Debian?

With free software, anyone can inspect the source code for malicious flaws. But most distributions provide binary packages to their users. We would like them to be able to verify that no flaws are introduced during the build process. The idea of “deterministic” or “reproducible” builds is to enable anyone to reproduce a byte-for-byte identical binary packages from a given source.

A research effort started last summer towards reproducible builds for Debian. After several small tweaks to core Debian tools, a massive rebuild in September reached 24% of builds resulting in identical binaries out of 5000+ source packages. The process uncovered challenges about both the reproducibility of the build environment and about the build processes themselves. We will review them, along with possible solutions and what remains to be done.

Welcome and introduction to the open document editors devroom.

Communication and collaboration between developers and systems administrators represent a key aspect of the "devops" cultural movement that has been growing in popularity over the last few years. Database administrators, most of the times, find themselves in between developers and sysadmins and their role is strategic. This talk will address some of the main concepts of "devops" as well as outline the reasons why Postgres can be considered the perfect companion in the database area.

Now in its third year, the FOSDEM Legal and Policy Issues DevRoom covers topics of licensing, legal, governance issues, and more as it relates to Open Source and Free Software projects.

Attendees are welcome to come and engage in lively debate with our excellent speakers. Please come with your questions, comments or concerns. The DevRoom talks are carefully chosen to avoid merely being introductory: we believe that FOSDEM attendees are well informed on these issues, and we welcome participation for all. Our goal in organizing this DevRoom is to bring the previously secretive and non-public discussion on these sorts of issues to a public forum.

A word of welcome, the devroom agenda, and other practical info followed by a brief introduction to HPC-UGent and the Flemish Supercomputer Centre (VSC).

This talk presents Synnefo's evolution since FOSDEM '13, focusing on its integration with Ganeti, Archipelago, and Ceph to deliver a unified, scalable storage substrate for IaaS clouds.

The talk will begin with an overview of the Synnefo architecture (Python, Django, Ganeti, and Xen or KVM). Then, it will introduce Archipelago, a software-defined, distributed storage layer that decouples Volume and File operations/logic from the underlying storage technology, used to store the actual data. Archipelago provides a unified way to provision, handle and present Files, Images, Volumes and Snapshots independently of the storage backend. We will focus on using Ceph/RADOS as a backend for Archipelago.

With Archipelago and its integration with Synnefo and Ganeti one can: * maintain commonly-used data sets as snapshots and attach them as read-only disks or writeable clones in VMs running the application, * begin with a base OS image, bundle all application and supporting library code inside it, and upload it to the Archipelago backend in a syncing, Dropbox-like manner, * start a parallel HPC application in hundreds of VMs, thinly provisioned from this Image, * modify the I/O processing pipeline to enable aggressive client-side caching for improved number of IOPS, * create point-in-time snapshots of running VM disks, * share snapshots with other users, with fine-grained Access Control Lists, * and sync them back to their PC for further processing.

The talk will include a live demonstration of a workflow including this functionality in the context of a large-scale public cloud.

The intended audience spans from enterprise users comparing cloud platforms, to developers who wish to discover a different design approach to IaaS clouds and storage virtualization.

Please see the abstract above for a rough sketch of the proposed presentation. The presentation will mostly consist of live demonstration and a small deck of slides, meant to describe the main features of Archipelago and its integration with Synnefo, as well as provoke discussion in the Q&A session.

The main workflow in the demonstration will be [copied and pasted from the Abstract]: * begin with a base OS image, bundle all application and supporting library code inside it, and upload it to the Archipelago backend in a syncing, Dropbox-like manner, * start a parallel HPC application in hundreds of VMs, thinly provisioned from this Image, * modify the I/O processing pipeline to enable aggressive client-side caching for improved number of IOPS, * create point-in-time snapshots of running VM disks, * share snapshots with other users, with fine-grained Access Control Lists, * and sync them back to their PC for further processing.

This talk presents Neev, a simple high-level networking library in C++ based on Boost.Asio that allows to setup client-server applications in a few lines of code. This library was designed and then used to code an add-on server for the game Battle for Wesnoth during Google Summer of Code.

Neev is an asynchronous and event-driven library for the networking on top of the Proactor/reactor design pattern (implemented by Boost.Asio). This is a small library for the networking part of any projects. We'll present it through the code of a simple example. We'll discuss the relation between the different coding styles and the strengths and weaknesses of event-driven development.

Welcome!

LanguageTool is an Open Source proofreading tool developed to detect errors that a common spell checker cannot find, including grammar and style issues. The talk shows how we run LanguageTool on Wikipedia texts, finding many errors (as well as a lot of false alarms). Errors are detected by searching for error patterns that can be specified in XML, making LanguageTool easily extensible.

LanguageTool exists since 2003, and it now contains almost 1000 patterns to detect errors in English texts. These patterns are a lot like regular expressions, only that they can, for example, also refer to the words' part-of-speech. The fact that all patterns are independent of each other makes adding more patterns easy. I'll explain the XML syntax of the rules and how more complicated errors, for which the XML syntax is not powerful enough, can be detected by writing Java code.

Running LanguageTool on a random 20,000 article subset of the English Wikipedia led to 37,000 errors being detected. However, many of these errors are false alarms, either because of problems with the Wikipedia syntax or because the LanguageTool error patterns are too strict. So we manually looked at 200 of the errors, finding that 29 of the 200 errors were real errors. Projected to the whole Wikipedia (currently at 4.3 million articles), that's about 1.1 million real errors - and that does not even count simple typos that could be detected by a spell checker. If you want less errors in your Wikipedia: LanguageTool offers a web-based tool to send corrections directly to Wikipedia with just a few clicks. And while these numbers refer to the English Wikipedia, LanguageTool also supports German, French, Polish, and many other languages.

This talk will contain lots of examples of errors that can be detected automatically, and others that can't. I'll also explain that LanguageTool itself is just a core written in Java (and available on Maven Central), but that it also comes with several front-ends: a stand-alone user interface, add-ons for LibreOffice/OpenOffice and Firefox and an embedded HTTP server.

A review of the past year in the life of the OpenJDK Community, with a particular focus on the nearly-finished JDK 8 release, the upcoming JDK 9 release, and a look ahead to planned process and infrastructure improvements.

Presentation about the communities around. The report will be based in gathering community metrics from the three projects. Code and Issues contributors will be covered and analyzed with total global metrics and the evolution in time of those metrics.

Using information in development repositories of MediaWiki, TWiki, and XWiki, this talk will explore how the communities are evolving. Different techniques will be used to show different aspects of the evolution, from analysis of commits or tickets to comparison of released source code.

A detailed analysis of how a software project is evolving, performing and behaving can be produced based on information in its development repositories. In this case, MediaWiki, TWiki and XWiki are analyzed, thanks to its open development model which allows for public access to those repositories.

The analysis includes several aspects of the project, and proposes some parameters that could be monitored to learn about how some of those aspects are evolving over time, so that corrective actions can be taken if needed. Some of the aspects that are analyzed are: the community of developers and contributors, the evolution of the source code, and the attention to tickets. Plots and graphs with various kinds of information obtained from this analysis will be presented, along with their interpretation and possible uses for the improvement of the project or the benefit of its users. The methodology and tools used for the analysis will also be explained, with the aim of letting others reproduce it.

As a result of the analysis, a dashboard with detailed information about the development of MediaWiki, TWiki and XWiki will be produced, made publicly available, and presented in the talk.

Many small and medium free software projects are staffed by volunteers that don't have any money to tempt a patent aggression entity. There's been plenty of talk about patent trolls, but money isn't the only motive for a patent suit. Even if non-practicing entities are eventually curtailed, ill-intentioned practicing entities may not be affected. The free software community will still have to worry about anti-competitive suits, nuisance suits and suits designed to spread fear, uncertainty and doubt about the adoption of free software. So, what can we as free software builders, promoters and users do to protect the code we care about?

Some solutions are only effective against non-practicing entities, while others may impact all kinds of bad actors. The strengths and weaknesses of proposed legislation, recent and ongoing campaigns and academic writings will be examined. If legislators and international trade negotiators won't take a stand against anti-competitive patent aggression, then we must do so as a community. Find out about some of the community solutions that are underway and how we can combat the threat of anti-FLOSS plaintiffs together.

Getting rid of the trolls won't be enough. We must also defend ourselves against those who mean to slowly bleed resources out of free software with unjust patent aggression.

Getting started with MySQL Performance Schema - a short overview of features available by default with zero efforts from user and zero config as well.

WebODF is an office suite for both local and cloud use. It works anywhere there is a browser or a browser widget. With WebODF you can edit office documents, share them, or publish them. WebODF is compatible with LibreOffice, Microsoft Office, OpenOffice and others, but can also be used stand-alone. It requires no special server software; it can be easily integrated with any web software.

Since WebODF started in 2010, it has grown in many directions. The new breakthrough feature is document editing. No other software makes it so easy to add office document editing functionality to your application. Not only did we add document editing, we added document editing for groups (collaborative editing). Good software is easy to use and packed with features. That is why we made viewer.js. It makes it easy to publish PDF and ODF documents on your website or display them in your content management system. In this talk, we will demonstrate all these exciting new features and explain how you can use them in your software.

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!

Convos is a modern IRC client for your browser, built in the Mojolicious framework using HTML5 Web Technologies like Web Sockets, Desktop Notifications, Media Queries, and Push State. It's always on, storing your messages in a Redis backend even when you are not connected. In my presentation, I will go through some of our technology choices and challenges in building a fully asynchronous Node.js-like application in Perl.

In this presentation, I will present a summary of the peculiarities of LibreOffice internals on iOS and Android, and tell about some recent advances like running as 64-bit ARM64 code on the newest iOS devices.

Note: I am intentionally using the term "LibreOffice code", not "LibreOffice".

Porting the LibreOffice codebase to iOS and Android was quite fun and many interesting issues had to be worked on. Some tasks were expected, like having to create new C++/UNO bridges for the two new platforms (not from scratch, but borrowing code from appropriate existing ones of course). Other issues were unexpected, like discovering the arbitrary and (relatively) low limit on the number of dynamic libraries loaded into a process on Android.

In general the restrictions placed on iOS apps that would require significant changes to some part of LibreOffice internals were well documented and known in advance, while restrictions in Android were undocumented, often presumably coincidental (or even simply bugs), and thus came as a surprise.

The porting efforts, and cross-compilation support in general, started back when we were still using a hybrid of old and new build mechanisms, which brought its own charms. But luckily dmake is dead now.

Compute-intensive applications usually benefit hugely from parallelization: running code on multiple CPU cores at the same time. One mechanism to implement such parallelism is to use OpenMP, an official open standard that allows for easy parallelization of existing C or C++ code. The latest OpenMP version (4.0, released summer 2013) also covers offloading to accelerators like GPUs and SIMD.

Klaas van Gend will introduce OpenMP, its applicability and usefulness and how to use OpenMP to speed up your code.

OpenMP is an official, open standard to specify multi-threading, computational offload (to accelerators like GPGPUs) and SIMD (vectorization). OpenMP is a big topic, it is impossible to cover everything.

Amongst the topics discussed will be:

• how to start using OpenMP
• the benefit of OpenMP: it is just code annotation
• how to implement functional parallelism: using parallel sections
• how to implement data parallelism: using parallel for
• how to work with OpenMP tasks
• simple comparison of OpenMP against 'competing' standards like OpenACC, OpenCL, C++11 and MPI
• the current state of the OpenMP implementations in GCC and Clang

SOM (Simple Object Machine) Smalltalk has Truffle-based and RPython (PyPy) based implementations. It shows modern ways of language implementations with the goal of achieving high performance.

This session will mostly concentrate on tips for designing and developing apps for the web as a platform while using the latest development tools and resources for Firefox OS in an efficient way.

With each passing day we see the web becoming more and more popular as a platform. What makes these apps so special? How can someone build such apps which aesthetically appeal to users? This session would be mostly concentrate on tips for designing and developing apps for the web as a platform while using the latest development tools and resources for Firefox OS such as the App Manager in an efficient way.

Red Hat's project of porting OpenJDK to run on ARM's new 64-bit architecture began about 18 months ago. This talk will describe the work we have performed over the last year, explaining how we went about implementing the client and server JIT compilers. In particular, we will give details and examples of how we have tuned the server compiler to generate code that has been optimized to make use of the AArch64 instruction set.

Red Hat's project of porting OpenJDK to run on ARM's new 64-bit architecture began about 18 months ago. Our rapid progress implementing the interpreted runtime was demonstrated at last year's FOSDEM. Since then we have completed our implementation of both the client and server JIT compilers and the project is now approaching its finishing stages. All of which implies that the first high quality, high performance Java runtime available to AArch64 developers will be Free Software.

This talk will describe the work we have performed over the last year, explaining how we went about implementing the two JIT compilers. In particular, we will give details of how we have tuned the server compiler to generate code that has been optimized to make use of the AArch64 instruction set. We will demonstrate the latter by running some example programs, displaying the generated AArch64 machine code and comparing it with the code generated by the x86 JIT compiler.

Tiki Wiki CMS Groupware (Tiki for short) is the Free and Open Source Web Application with the most built-in features. It also has a very open developer community policy which supports "the wiki way of writing software". This emphasizes some common challenges, especially in terms of debugging and bug reporting.

This talk is about the infrastructure at show.tiki.org which we have set up for bug reporters to showcase the bugs on a running Tiki instance.

This project was started during the April 2013 Ottawa TikiFest where we pondered ways of improving Tiki by improving our debugging process. We have already had a bug tracker for ages, but too many bugs stay unresolved because they are not understood or not reproduced by the volunteer developers.

So we started this new project to facilitate bug reporting and solving. It can be quite time consuming to read and understand some of the bug reports (They are often edge cases). Experience shows that if you can demonstrate a bug (and for a regression, pinpoint which commit introduces it), things can get fixed quickly.

This talk will:

• Explain what issues this infrastructure solves
• Explain the benefits to bug reporters and how they use it
• Explain the benefits to developers and how they use it
• Explain the scope, early requirements, technical choices and plans for the future
• Describe the underlying technical infrastructure
• What was postponed/is planned for version 2.

This is a very successful project which brought many benefits to the Tiki community. Both users and coders appreciate it. It hosts 200 live sites after 4 months of existence. There will definitely be a version 2.

We feel it could be of benefit to other web-based projects. It might be either reproduced from general principles by rewriting and adapting our code or, if there is interest, it could be branched off Tiki and expanded as a more generic solution for any wiki (or web-based) application.

Porting a X window manager to the wayland protocol is huge task. This talk describes the journey we took to make it possible to run Enlightenment as a standalone wayland compositor.

While the Enlightenment project has had support for wayland in the EFL toolkit for a long time, the window manager itself always relied on some pieces of X for things like input devices, VT switching, etc.

In this talk we will lay out what problems we faced and also show our solutions. We will talk about the handling of input devices, interaction with DRM, VT handling as well as missing pieces of the wayland protocol for a full desktop experience. For compatibility we are using XWayland with integration into the window manager to launch XWayland if needed.

The end result is Enlightenment running without any X dependencies

MySQL offers two paths for users who want to add custom functions: SQL stored routines (SRs) and user-defined functions (UDFs).

SRs are simple to create, safe to execute, and offer features such as SQL queries. Their downside is poor performance, clunky syntax, and no support for aggregate functions. UDFs are harder to create and can be unsafe. However, performance is about as fast as it ever gets. UDFs do support aggregate functions.

Stored Routines are simple to create and safe to execute and offer features such as SQL queries. Their downside is poor performance, clunky syntax, and no support for aggregate functions. User-defined functions are usually coded in C/C++ and are typically harder to create and can be unsafe. However, performance is about as fast as it ever gets. UDFs do support aggregate functions.

The MySQLv8UDFs project offers UDFs that exposes the UDF interface to Google’s v8 JavaScript engine. This enables you to write MySQL scalar and aggregate functions in JavaScript. Although typically not as fast as C/C++ UDFs, we have examples where the javascript UDF solution is 5-8 times the performance of stored SQL functions, and even 2 times faster than the equivalent straight SQL expression. For more computationally intensive tasks, the javascript UDFs easily win from MySQL stored functions, while being relatively easy to code as compared to a straight C/C++ UDF.

Apart from just UDFs to run javascript, the javascript environment offers many useful built-ins. Apart from the standard javascript built-ins, which include powerful string functions, an expressive and fast regular expression engine, and a convenient and safe JSON parser/serializer, MySQLv8udfs adds a number of utilities that are useful in a specfic MySQL context, such as functions to write to the MySQL error log and a fully functional MySQL client that allows you run queries to any MySQL server accessible through the network.

Code: https://github.com/rpbouman/mysqlv8udfs.

Samsung will present the challenges of creating a dual-Android platform on the Nexus 10 (Cortex A15 based) using Xen on ARM. Samsung has been endeavoring to run XEN on ARM based mobile devices using para-virtualization for CortexA9 devices earlier and now with virtualization extensions on cortexA15 devices.

The primary end user use case is BYOD(Bring Your Own Device), where two isolated OSs run simultaneously. One OS would be “personal” OS and the other a “work” OS. The user experience should not deteriorate in either of the OSs and GPU is the biggest hurdle in achieving this. Samsung would present its approach in virtualization of the GPU within the context of XEN and discuss the challenges encountered in achieving a good FPS(frames per second) in both OSs (two Androids in this case).

The main points would be stress the following points * Virtualization on mobile devices and user experience importance for its success. * GPU virtualization is achievable with very good performance using XEN. * XEN and open source collaboration from Samsung. * Paravirtualization cahllenges of IO/peripheral devices on a typical Mobile device with virtualization extension support for CPU and Memory.

Presentation on the two changes in Writer for Apache OpenOffice 4.1 regarding 'fields' from the developers point of view. The in-place editing of Input Fields is the one PoV, the other is the enhancement of comments/annotations to apply them on arbitrary text ranges.

Two changes made in Writer for Apache OpenOffice 4.1 are presented from the developers point of view. One of these changes is to improve the user experience for editing Input Fields - the content of these fields can now be filled/changed directly inside the text document's content. The other is the enhancement to apply comments/annotations to arbitrary text ranges. The enhancement for the comments/annotations based on patches provided by the OOXML improvement project, initiated by the OSBA. First the impact of these changes for the user - which is the ultimate motivation for these changes - will be shortly presented. Afterwards the talk will concentrate on the code changes itself. It will be shown what kind of changes were needed and which parts of the code were touched. It will become clear why these two changes are somehow similar regarding the touched code. Used features, like the overlays from the drawing layer, will be discussed in detail. It is planned to give room for discussions on the made changes for better understanding, knowledge sharing and hopefully also further code improvements.

PostgreSQL has added some wonderful new JSON features in 9.2 and 9.3. They look fascinating, exciting, and should have all kinds of great applications...

Like what?

We'll talk about some real-life use-cases that actual companies are deploying, and what the trade-offs, performance issues, and challenges they've faced are.

Pharo 2 was released in March 2013. Not even a year later, we are close to the release of Pharo3. With over 1200 issues fixed and many deep changes, it is the release with most changes yet.

This talk will give an overview of the changes and improvements done and present some examples of what can be done with Pharo3.

Witer internals: How are the pages rendered?

Recent trends in software development have raised questions as to whether package management in Linux distributions is still relevant. Whether it's independent package managers in popular Web frameworks and languages (Node.js, Ruby, Python, etc) or bundling and containerization that's become increasingly popular in DevOps culture, it appears that integrated approaches to package management are on the decline. Yet at the same time we've seen package managers in the Windows world such as NuGet grow more popular. This talk from a leader of the Gentoo Linux distribution will explore the reasoning and history behind this shift and whether it's the right move for the FLOSS movement as a whole.

We'll provide an overview of what happened with Firefox for Android in the past year. What features did we add, what performance improvements did we achieve, what usability improvements we made, and what entertaining stories we can tell from that experience? Also, where did we fail and where are we still aiming to improve?

In 2011, Twitter embarked on creating an open source office. Since there's no real book out there when it comes to starting an open source office, we have a lot of interesting/hilarious lessons and stories to tell about the experience.

From how we handle open source compliance issues to starting an open data program to our attitudes towards open source, there's lessons to share. In particular, we will share our views on:

• open source licenses: strong copyleft versus weak copyleft
• scalable open source policies for engineers
• open source foundations vs. github
• practical open data

Ada is one of very few programming languages that support multi-threading as part of the language, as opposed to libraries.

Last year, we showed how Ada makes it easy to turn a single-threaded program into a multi-threaded program. We ended up with ten thousand threads working concurrently. I will briefly recap this first episode and then continue with the same program, introducing a task pool wherein a small number of threads (one per processor core) process thousands of small work units.

This presentation will feature live editing of source code, compilation, and debugging. Questions from beginners are encouraged. It is not necessary to have attended the first installment. The sources of our example program will be provided to those who want to tinker with them.

Language Coverage Matrix Dashboard, a product supported by the Language Engineering Team, aims to provide an overview of all the resources that are available for Wikipedia and its sister projects. The talk will cover the basic introduction to this product, followed by the detailed description of its architecture, roadmap, and future plans.

Language Engineering Team of the Wikimedia Foundation actively works on building the language support for Wikipedia and its sister projects. For all the 300 different languages that these wikis are available in, the team works on developing the support for various fonts and input methods to provide the users with all manner of language related technical support that are needed. Clearly, there was a need of gathering all the information around the language support and the resources for the languages currently supported in the Wikimedia sites, provided by the Language Engineering team. Language Coverage Matrix Dashboard is aimed to serve that purpose.

An instance of the Dashboard is now up on Wikimedia Labs. While the database has MySQL in background, it's a single page website with JavaScript filters to automate the search. This also has got an API console to generate raw data about the language components along with the query detail, that could be used to implement the data on any web-project.

In the talk, a basic introduction to LCMD will be given, along with a demo of the product. While the basic features will be shown in the demo, there will be a discussion about that in the talk. A detailed description of the architecture and the technologies used will talked about as well. I hope to interact with the audience during this session especially about the visualization of the data, which is the next area of focus for the product. I also look forward to receiving feedback from users and developers already familiar with the LCMD or similar dashboards.

Language Coverage Matrix Dashboard has been developed as a Google Summer of Code project by Harsh Kothari under the mentorship of Runa Bhattacharjee and Alolita Sharma. I have been associated with it since quite some time and have been working on the maintenance of the product. I would like to add Harsh Kothari as the co-speaker, who has been the primary developer for the project.

This talk will explain how to use DTrace, where to use it, and how to quickly introduce DTrace in your applications.

DTrace is a powerful framework for tracing applications on the fly. We will look at:

• How DTrace works
• Who DTrace uses
• How to use DTrace
• How to integrate it in your awesome applications

How I automated myself out of my job.

About a year ago I accepted a new job in an enterprise Linux environment, running ~450 Linux servers. These servers were running on an internal network and had never been updated. Most work was done ad-hoc and in response to issues or failure.

I transformed the team to a pro-active way of working where automation was key. By solving the most frequent problems first, we found the time to automate more and more. Every server was updated and configuration management was introduced.

One interesting year later I've automated myself out of my job. The team can easily handle the (now much lighter) workload without me. Users are happy, so mission completed!

Configuration management is done using CFEngine 3 and we use other DevOps style tools like Git, Vagrant, Trello, Logstash etc.

In this talk I'll talk about the journey we took and answer:

• What was the problem with the old way of working?
• How did we implement configuration management in an already running environment?
• Why did we choose CFEngine 3?
• What is the new way of working?
• What are the lessons learned?
• How to automate yourself out of your job?

To get an idea: I have recently written blog post about the technical side of the story: http://blog.remibergsma.com/2013/08/31/managing-hundreds-of-servers-with-cfengine-and-git-full-control-over-configuration/

The presentation will also focus on the process of getting there and the lessons learned, so others can benefit.

A Future object represents an operation that is currently in progress, or has recently completed. It can be used in a variety of ways to manage the flow of control and data, through an asynchronous program. It is intended that library functions which perform asynchronous operations would use future objects to represent outstanding operations, and allow their calling programs to control or wait for these operations to complete.

Most open source projects are rightly proud of their communities, long histories (both measured in time and version control), passionate debates and occasional trolling. Newcomers to these communities often face an uphill battle, though. Not just in understanding decision making processes and community standards, but in coming to terms with often complex, contradictory, and poorly documented code bases. This talk will introduce you to the concepts and tools you need to be an expert code, culture, and community archaeologist and quickly become productive and knowledgeable in an unknown or legacy code base.

This talk will introduce you to the concepts and tools you need to be an expert code, culture and community archaeologist and quickly become productive and knowledgeable in an unknown or legacy code base and will cover:

• Navigating culture
• Understanding open source communities and how to become part of one
• Spelunking legacy code bases
• Reverse documentation
• Tests, testing, and statistics
• Modeling, profiling, and tracing
• Avoiding curses, rolling boulders, and snakes

You'll learn how to navigate code, community, and culture in open source projects and learn skills that are useful in any legacy code base.

Current garbage collectors for OpenJDK all need to stop the application periodically to perform garbage collection tasks. This is a scalability bottleneck because those pause times are dependend on heap size. Shenandoah is a new garbage collector for OpenJDK, currently developed by Red Hat, that aims to reduce GC pause times to a minimum by implementing marking and object evacuation to run concurrently with application threads, and utilizing parallel garbage collection threads.

Current garbage collectors for OpenJDK all need to stop the application periodically to perform garbage collection tasks. This is a scalability bottleneck because those pause times are dependend on heap size. This is a problem for large-scale applications that require 100GB+ of heap. Shenandoah is a new garbage collector for OpenJDK, currently developed by Red Hat, that aims to reduce GC pause times to a minimum. Specifically, pause time are no longer dependend on heap size. It implements marking and object evacuation to run concurrently with application threads, and utilizing parallel garbage collection threads.

In this talk I want to introduce the Shenandoah GC, talk about our motivations, present the technical innvoations that enable Shenandoah to achieve concurrent marking and evacuation, compare Shenandoah with other garbage collectors, and finally give an overview of what we plan to do in the future.

Three years ago a small team at Intel took on the task of rewriting the OpenGL Shading Language compiler in Mesa. One of the most fundamental design choices in any compiler is the intermediate representation (IR) used for programs. The IR is the internal data structure used for all program transformations including optimization and code generation. At the time the compiler was designed, a number of alternatives were investigated. In the end, a tree-like IR was selected. With hindsight being 20/20, this talk will present the tree-like IR that was chosen and the issues that have been found with that IR in the interim.

Xilinx and Altera both took the next step in integrating System on Chips (SoC) with Field Programmable Gate Arrays (FPGA): put them both on the same die and connect them with a high speed interface. This talk will describe the Altera Socfpga platform, its current support in the mainline Linux kernel, lessons learned in using the vendor supplied information and what this new kind of dual core CPU and FPGA alliance opens up for possibilities in low latency RT applications.

Galera Cluster is a synchronous multi-master cluster for MySQL which allows you to synchronously replicate your data to every node in the cluster. Galera Cluster makes the life of a DBA easier with features like automatic node joining, electing donor nodes, and automatic node removal once a node has failed. There is no need to distinguish master and slave relations in your application as all nodes in the cluster are writable. Consider all nodes in the cluster as one big MySQL database server.

The session will include design choices, lessons learned, and the pitfalls us at Spil Games fell into.

In this talk I will explain how Spil Games strives to have their entire MySQL environment running on Galera Cluster. At Spil Games we have a large variety of MySQL implementations ranging from traditional functionally sharded database master-master pairs, single masters with many read slaves and user/location sharded database nodes. Migrating these different implementations to a Galera Cluster requires careful planning.

The biggest challenge is to migrate all our existing (ageing) asynchronous Master-Master setup to a synchronous Galera replicator. Because the ageing servers are less performant than the new servers used for Galera we merge multiple existing clusters into one cluster, saving us lots of space and power in our data center.

The session will include design choices, learnings and the pitfalls we fell into.

A talk on engaging the F/OSS community and the lessons learned in the many releases after GNOME 3. Discuss measures we took to engage community, the effect of social media in the modern age, and lessons for others who also release software.

Bad news travel fast, ugly news travel even faster. The world was not the same when GNOME released 2.0, and in today's world you need to know how to engage with the community, apply damage control when needed, and understand how information propagates through social media and to create an effective message.

This talk is about the key lessons we learned when releasing GNOME 3.0 and subsequent releases after and discuss possible solutions, or the measures we have used to help reduce friction with the community.

This talk will cover the basics of autoscaling, different types of auto-scaling, and how you can use your metrics to take good auto-scaling decisions. Targeted to entry level to mid level auto-scaling users.

• What is autoscaling
• Different kinds of traffic peak scenarios
• Autoscaling reactive vs proactive
• Autoscaling with external tools - Rightscale, Autoscale API, Heat, Ceilometer
• Autoscaling with your metrics - Graphite, Provisioning, Configuration Management

Kadeploy is a scalable, efficient, and reliable bare-metal provisioning solution for HPC clusters. In this talk, I will first present the design choices that enable system administrators to install a 300-nodes cluster in a couple of minutes. Then, I will present how Kadeploy is used in the context of the Grid'5000 testbed. Grid'5000 is a large-scale testbed for research on HPC, Cloud, Grid and P2P computing, where Kadeploy provides users with the ability to deploy their own software stacks, making it the ideal testbed to design, test and evaluate IaaS Cloud stacks.

Links: http://kadeploy3.gforge.inria.fr/ http://www.grid5000.fr/

What we did in 2013, the cool dev tools we got for X-mas, the great stuff we’re planning for 2014, and how to get a free tablet.

The MediaWiki Translate extension was first introduced in 2007. Initially it was only used on translatewiki.net for software localisation. Later it was enabled on KDE's userbase wiki for translating their documentation. These days, the Translate extension is also used on Wikimedia wikis where the equivalent of more than one thousand A4 pages of pages of structured documentations is being translated each month. The next step is a feature for the mass translation of Wikipedia pages into any language combination to combine machine translation and content generation to allow every single human to freely share in the sum of all knowledge.

The PowerPC/AIX porting project currently driven by IBM and SAP is a good example how the OpenJDK fosters the cooperation of different players in the Java ecosystem in an open environment. At last years' FOSDEM, we presented our JCK-certified JDK7 port. This year, we will showcase our JDK8 port. But more importantly, we will describe the lengthy process of integrating the port into the main OpenJDK repository, thus making it a first class citizen in the OpenJDK environment.

The PowerPC/AIX porting project currently driven by IBM and SAP is a good example how the OpenJDK fosters the cooperation of different players in the Java ecosystem in an open environment.

At last years FOSDEM, we presented our JCK-certified JDK7 port. This year, we will showcase our JDK8 port. But more importantly, we will describe the lengthy process of integrating the port into the main OpenJDK repository, thus making it a first class citizen in the OpenJDK environment. This process includes the creation of a JDK Enhancement Proposals, the agreement on a detailed Integration Plan between all parties, the thorough review of all changes by OpenJDK reviewers, the integration into the main development repositories and finally the downport into a released version.

Of course we will also highlight the general improvements in the OpenJDK code base which are the result of our port. Finally, we will be happy to answer any kind of technical questions regarding a JDK port to a new CPU and OS platform.

The OASIS Advanced Document Collaboration subcommittee is working on an update of OpenDocument change-tracking (CT). The update will not only enhance the existing CT feature set to the current state of the art, e.g. tracking style changes, but also lay the foundation for the standardization of real-time collaboration (RTC) by making CT compatible to RTC.

The new design in a nutshell Pattern of trackable changes of OpenDocument will be derived from common user actions and defined as "operations". The overall design of ODF change-tracking will change from a before/after XML design to a sequence of serialized operations, improving the merge ability using Operational Transformation. To split overall complexity the overall set of valid documents defined by the RelaxNG schema will be split into smaller XML components based on semantic entities known by the user, e.g. table, image, paragraph and character. A complete XML document tree is mappable to a component tree and operations are always referring to a component they are altering, choosing one of the 6 meta operation types: add, remove, split, merge, move and replace. The theory part - new design in a nutshell Pattern of trackable changes of OpenDocument will be derived from common user actions and defined as "operations". The overall design of ODF change-tracking will change from a before/after XML design to a sequence of serialized operations, improving the merge ability using Operational Transformation. To split overall complexity the overall set of valid documents defined by the RelaxNG schema will be split into smaller XML components based on semantic entities known by the user, e.g. table, image, paragraph and character. A complete XML document tree is mappable to a component tree and operations are always referring to a component they are altering, choosing one of the 6 meta operation types: add, remove, split, merge, move and replace.

ABF as a development framework with ARM-powered build nodes by the example of OpenMandriva 2013.0 / Cooker armv7hl

1. OpenMandriva 2013.0 / Cooker armv7hl (Development Release) Little presentation of OpenMandriva distro on Freescale ARM devices with RazorQt and KDE

2. Automated Build Farm (abf.io) as a development framework

3. what is it and what differences from other systems

4. external nodes for building packages on ARM and other platforms

5. WandBoard (www.wandboard.org) as a simple build node for Automated Build Farm cluster.

6. How it works?
7. Why we use it?
8. Perfomance

After 4 years of "experience in the trenches" providing enterprise configuration management solutions based on CFEngine 3, it became clear that our customers wanted CFEngine's speed, small footprint, and features but were having a hard time with the language and tooling, and needed an easier way.

The goal of ncf is to abstract the knowledge of "how" to achieve tasks in CFEngine, and expose these capabilities for non-expert users. Thus, you can express your intent in a very succinct and expressive manner, integrating simply with CFEngine and its power, while keeping everything "under the hood" tunable.

ncf promotes DRY-ness and sharing knowledge. It is built from the ground-up to be easy to learn, flexible and extensible. The framework is written in pure CFEngine language, introducing a well-structured design built on multiple decoupled layers with clearly-defined interfaces and roles.

In our presentation we will introduce ncf and explain how ncf can be used to solve real-world examples, explain our design choices, the architectural approach taken, and demo the new magic at our finger tips to build CFEngine solutions that are extensible and easier to work with.

15 tips to boost your Galera Cluster.

During this presentation, I will show how to implement several stuff that will improve your day-to-day workload.

The points will cover topics like Point in Time Recovery, WAN replication with group segments, Avoiding SST when adding new Percona XtraDB Cluster node, ... the tips will be briefly explained to the audience and then put in practice.

Currently, the covered tips are:

• Point in Time Recovery
• Accelerate XtraBAckup SST
• Move async slave to a new master 5.5
• Move async slave to a new master 5.6
• Allow longer downtime for a node
• Measuring Max Replication Throughput on Percona XtraDB Cluster with wsrep_desync
• Multicast replication
• SSL everywhere
• decode GRA* files
• Realtime stats to pay attention to in Percona XtraDB Cluster and Galera
• Avoiding SST when adding new Percona XtraDB Cluster node
• Play with quorum and weight
• WAN replication with group segments
• Load balancer and TIME_WAIT
• Load balancer and persistent connections

OX Documents is a browser based ODF editor using the upcoming OASIS ODF change operations as principle design.

OX Documents is a combination of word processing, spreadsheet and presentation editor. Released is OX Text, which directly reads and writes native ODF and OOXML documents without loss of format. Known document parts are sent to clients via operations and user changes are merged back into the DOM on the server. Merging is easy as OX Text already uses the upcoming ODF change operations as principle design. This session provides a brief introduction of the operation design in OX Text and lessons being learned.

How can one get the most out of the Perl community? Good question! I'm so glad you asked.

In this presentation, Salve J. Nilsen attempts to give a concise and information-rich overview of what the Perl community can offer, what to expect, and how to get the most out of it. The intended audience is everyone who wants to be ore useful and effective with Perl, and isn't already familiar with the community.

In this talk you'll find answers to questions like...

• Where and how do I find Perl people to have a beer with?
• How do I find out which modules are cool, powerful and the the easiest to work with?
• How can I find useful software, good recommendations and what the current best practices are?
• What are the most useful community services offered, and how can I get the most out of them?
• How can I build a positive reputation within the Perl community? 
• How can my employment opportunities and pay grade be improved with the help of the Perl community?

With kdbus we move the D-Bus IPC system into the Linux kernel to improve performance and functionality while keeping compatibility.

Most more modern OS designs than Unix started out with a high-level IPC from the beginning, and then built the rest of the OS on top of it. Linux/Unix began with only the most basic low-level IPC primitives in place (Pipes and AF_UNIX sockets). Building on those over time various higher-level IPC systems were built, but only very few stood the test of time or became universal. On current Linux systems the best established high-level IPC layer is D-Bus. It implements a reliable message passing scheme, with access control, multicasting, filtering, introspection and supports a flexible object model.

D-Bus is a powerful design. However, being mostly a userspace solution its latency and throughput are not ideal. A full transaction consisting of method call and method reply requires 10 (!) copy operations for the messages passed. It is only useful for transfer of control messages, and not capable of streaming larger amounts of data.

In this talk I'd like to discuss the "kdbus" IPC system, a kernel implementation of the D-Bus logic and its userspace side. "kdbus" takes the concepts of classic D-Bus but makes them more universally useful, reducing latency and roundtrips, and increasing bandwidth, even covering streaming usecases. (For comparison, with kdbus, a full transaction takes only 2 copy operations, even supporting zero-copy for large messages). I'll discuss the lessons we learnt from Android's binder, Solaris' doors IPC system, and Mach's port scheme. We'll discuss how we implemented a reliable (though probabilistic) multicasting scheme, and the tricks we used in userspace to make transparent zero-copy work, without compromising on security, and providing compatibility with classic D-Bus.

kdbus might soon show up in your favourite distribution as part of the systemd package, please attend if you want to know more about the ideas behind it.

Quattor is a systems administration toolkit allowing controlling the whole life cycle of large and very large computer fabrics. It aims to provide great flexibility (use as much or as little of it as you want), accuracy, and consistency (catching lots of configuration errors way before deployment) and scalability, with installations from tens to tens of thousands of systems.

In this talk we'll describe the main characteristics of Quattor, its simple language and show how a simple service can be deployed.

Quattor is a systems administration toolkit started in the LHC Computing Grid and used in several academic and commercial environments, ranging from tens to over 30,000 systems.

In this talk we'll cover the basics of the Quattor architecture, how different tools are integrated together to manage the entire life cycle of a system, and give a minimal example of a configuration with Quattor.

We'll explain briefly how the Pan language helps in re-use of configurations, consistency and correctness. We'll give a quick overview of some tools available in the Quattor toolkit to install hosts and show how a part of a host can be put easily under Quattor control.

Opening of the Lightning Talks at FOSDEM14.

Once Upon a Primitive Slideshow, and other news from LibreOffice graphics.

This talk will outline recent progress on bringing forward slideshow and graphics stack in LibreOffice. Helpful pointers to code and feature branches will be given, and should you show up, expect to be chatted up for providing patches!

This presentation will detail the reasons, objective, status and roadmap of the EdgeBSD project, which started from the NetBSD codebase earlier this year. It aims at broadening and experimenting around community development around NetBSD thanks to a tentatively more modern development workflow, based on Git.

NetBSD is arguably the first community-based Free/Open Source Software project: it featured a public version control system and mailing-lists back during its inception, 20 years ago. Driven by its very thorough approach to development and technical design, it gained and deserved a reputation of being clean, portable, and simply a cool platform to work and research on.

Over the years, NetBSD received contributions from hundreds of developers, pioneering in areas such as cryptography, host security, networking, and virtualization. However, its rigorous code & member integration process can also be seen as harmful, especially when compared to modern project management and distributed version control systems.

This is where EdgeBSD kicks in. A new member of the family of BSD-based Operating Systems, it is starting development with the current NetBSD codebase and Git for Source Code Management. Package management is based on pkgsrc.

The primary goal of EdgeBSD is to provide an ambitious environment for working as a bigger community on the NetBSD Project. This will be achieved thanks to a more modern development infrastructure, while taking a more aggressive stance on integrating and enabling features (many readily available).

Ultimately, EdgeBSD should be just as fun and attractive as a Research & Development platform while delivering a modern, robust, and industrial-grade system for all ranges of computer devices, thanks to a more versatile and personalized development workflow.

Safety Critical Devices.

We rely on software more and more for critical functionality in our society. Medical Devices and Cars are two areas where our lives literally depend on the safety of this software. As more exploits are demonstrated on cars, pacemakers and insulin pumps that show them to be vulnerable, the industries are evaluating their technology and some are advocating for free software as partial solution to these problems. This panel will discuss free software in Safety critical devices. including the implications of different licenses, issues regarding warranties and indemnities and liability issues for manufacturers The panel will discuss automotive and medical devices and consider regulatory issues.

Progress made in squeak the past year and a look at the development of spur, the new VM.

Sage is an open source mathematical software system that is built on many components, such as Python, sympy, numpy, gap and scipy, and also brings along the power of the Python programming language. This talk will introduce cover some capabilities of Sage and enable participants to use Sage for their computation needs.

Sage is an open source mathematical software system that is built on many components, such as Python, sympy, numpy, gap and scipy, and also brings along the power of the Python programming language. It greatly augments the Python programming language with a rich set of libraries that enable number theoretic computations, differential and integral calculus, combinatorics, polynomials, matrix operations, cryptographic functions, 2D/3D plotting, etc. to be performed from Sage. Sage also uses iPython, a wonderful interactive shell for Python with features such as saving session history, autocomplete etc. Sage also has a notebook interface(with an authentication system) which enables users to collaborate with each other on Sage projects.

It would be impossible to cover everything about Sage. I will try to cover some applications of Sage which will be useful to a majority of people interested in using Python for mathematical computations.

Below is a broad outline of the various topics I hope to cover. 1. Introduction: Modes, usage, customizing. 2. Arithmetic and built-in functions. 3. Algebra related functions. 4. Graph plotting. 5. Number theory. 6. Matrices. 7. Generating LaTeX representation of Sage code. 8. Calling Sage functions from LaTeX. 9. Writing Sage scripts. 10. Conclusion and further reading.

You are a collection of code. You’ve got your initial commit from your parents, the pull requests of childhood influences that they either rejected or accepted, and then you’ve got you, grown up project who can decide how you want to develop. (Pun fully intended.)

How do you continue to develop, i.e. mature as a human being? You expose your code and accept pull requests. IRL, that means sharing your background (bugs and all) and integrating lessons from other people because it turns out the same things that make a good open source project make a good open source person. While you could certainly be a closed source project that doesn’t make any changes unless you see a clear benefit to you, that results in a life where you miss opportunities to better yourself simply due to someone believing you can be better.

This talk will take the criteria that make a good open source project and explore how they can be applied to being a good "open source person."

What is Persona? How does it work? What are benefits of Persona? Let's see it through a demo!

While “total number of page views” still serves as simple, purely traffic-based metric to compare sites, it is an often misused metric around wikis. Management, analysts, and wiki communities have different understandings about which requests (should) qualify as page views. We exhibit the key differences, expose the resulting challenges and finally discuss possible solutions in a Wikipedia context.

A short talk on common programming APIs used by games as well as creating simple Doom 3 levels and menus - with examples from current programming projects AdaDoom3 and a Neotokyo tribute modification.

The state of the FLOSS graphics stack is rapidly changing and so is the X.org foundation. We are currently working on merging with SPI to get rid of the bureaucracy that goes along with having the non-profit association status in the USA (501(c)(3)). Since we are changing our legal status, it is also grand-time for us to broaden our purpose beyond the X Windowing System. Projects like Mesa and Wayland have accepted to be placed under the X.org foundation umbrella, it is time for us to make it clear that the X.org foundation is not only about X anymore! This talk will also advise people to become members of the foundation in order to get a voice in this process.

Due to resource constraints common in sensor nodes it is often complicated to profile the performance of an application. One solution is simulating the node and profiling the application in there. This talk presents a flexible infrastructure to generate a call graph and calculate the function runtime.

In the past, a lot of effort has been invested in high performance kernel tracing tools, but now the focus of the tracing community seems to be shifting over to efficient user space application tracing. By providing joint kernel and user space tracing, developers now have deeper insights into their applications. Furthermore, system administrators can now put in place a new way to monitor and debug systems using a low intrusiveness tracing system, LTTng.

This presentation explains how LTTng can be used as a powerful development and debugging tool for user space applications taking advantage of this year's exciting new features such as network streaming and snapshots. It demonstrates how open source developers and hackers can use LTTng kernel and user space tracers to create powerful logging systems and easier debugging, thus greatly improving development and maintainability of their project(s).

Finally, this talk concludes with the future work we will be doing on LTTng, and how the community can help with improving the project from feedback to very valuable contributions.

Learn about how to use the OSS Automation Platform Chef to deploy the OSS Cloud Platform Cloudstack.

Learn about how to use the OSS Automation Platform Chef to deploy the OSS Cloud Platform Cloudstack. In this talk I'll cover the steps and gotchas in writing cookbooks to deploy Cloudstack, the reasons for doing so, and the ways the deployment process was optimized to cut the overall time required to deploy. Additionally we'll talk about how to automatically configure the Cloudstack environment once it is deployed.

PostgreSQL 9.3 was released in September 2013, but the development of 9.4 is close to reaching beta. This talk will take a look at some of the things that are available in what will eventually become PostgreSQL 9.4.

A personal talk about what happened when a car crash left me in a coma for three days and the recovery that has happened in the two years since. The ups and downs of this is mixed with the ups and downs of developing a KDE Linux distro, Kubuntu.

Network Function Virtualization and Network Service Insertion and Chaining has several advantages like reducing the CAPEX and OPEX along with ease of use for Network Services deployment. In this session we describe how these dynamic network service requirements can be handled using KVM, libvirt and Openstack. They can understand how virtualization can be used for designing systems for data centre environment. Basic knowledge of virtualization would be helpful while attending the session.

Key Goals for this Talk:

i)Deployment of Network Function Virtualization using OpenStack and OpenFlow Controller in DC networks. ii) Network Service Insertion and Chaining Deployment using OpenStack iii) NFV using KVM Hypervisor and Libvirt, Improvements for NFV performance. iv)Cloud Resource Discovery Service for NFV deployments with OpenStack and OpenFlow Controller v) Advantages of NFV and Network Service Insertion and Chaining using OpenStack.

Sphinx is one of the best open-source alternative to replace MySQLs full text indices. This is not only because of its superior speed and smaller resource usage, but also because it provides extended features for full text searching, which are not available on MySQL FTS indices.

The talk will do a quick exploration on the syntax used for creating fulltext queries. Sphinx offers text matching operators like proximity, qourum, strict order operators as well as some special operators like SENTENCE,PARAGRAPH,ZONE. In Sphinx it's possible to choose between several built-in rankers, but also offers users a way to build custom ranking expressions with the expression ranker. Currently there are over 20 metrics that can be used to build a custom ranking expression. Also Sphinx comes with a SQL dialect for communication, which makes an easy transition from a FTS MySQL query to a Sphinx query.

Reusing images shared with Creative Commons licenses would be much easier if we could use tools that keep track of the attribution and license metadata for the images. This talk shows how this can be done today with a set of plugins to Firefox and LibreOffice/OpenOffice, and what could be done better with improved support in the plugin APIs.

It is common to use images from e.g. Flickr to make a presentation or a document more engaging. Photographers can license their images with one of the Creative Commons licenses to allow this reuse, but they require that you credit the original creator by providing an attribution, preferably with a link to the original image, and the license information. This is typically done in the image caption in a document, or on an attribution slide towards the end of a presentation.

The information required for the credit is sometimes available as machine-readable metadata, e.g. embedded as XMP in the file itself or as RDFa on the source web page. Tools can extract the attribution and license properties from this metadata and automatically insert credits in suitable places. Support for metadata is not very widespread today, but would make it much easier to reuse images by drastically reducing the effort for providing the required attribution.

The plugins and libraries developed by Commons Machinery support using RDFa metadata on copy-paste. When an image is copied from Firefox using the plugin, both the image and the RDF triples are copied to the clipboard. The LibreOffice/OpenOffice plugin pick up the properties together with the image when it is pasted to automatically generate a correct attribution. The talk will explain how this works, and suggest improvements to the plugin APIs and to LibreOffice/OpenOffice to make this metadata even more useful in ODF documents.

Aquilon is the third generation configuration data-store for Quattor (The first being CDB and the second being SCDB).

This talk will cover the architecture and motivation behind Aquilon, experience from a site migrating to it and some examples of the power it can give to SysAdmins.

Aquilon features a broker daemon with overall ownership of the system including profile compilation and host notification. The broker models an organisation's infrastructure as objects in a RDBMS, generating configuration code from this as needed. User interaction takes place over a kerberos secured connection to the broker, which delegates sandboxes (cloned git branches) to users when changes to configuration code is needed.

Entangle is an open source project that provides a Linux desktop application for “tethered shooting”. It uses the ligphoto2 library to trigger the camera shutter, preview shots via the camera's "live view" capability, download captured images and access all the live camera settings. It is useful for a variety of use cases including studio model shoots, macro still life, stop motion animation shoots, astro-photography and more.

The talk will be targeted at Linux users & developers who are photographers interested in any of the aforementioned use cases.

The talk will provide an overview of the important capabilities of the program and, if all goes to plan, a live demonstration of the application in use.

The aim is to demonstrate the potential of the application to users who are not already aware of its existence, and attract open source developers to contribute to the project.

A short overview of the new time based charting feature in Libreoffice.

Libreoffice brings now support for new time based charting. We will present this new feature and show some possible development ideas for the future. Additionally we we show the new 4D real time charting that is possible with this new approach.

Mozilla has 4 pillars of activity, to build, empower, teach, and shape the web. One of the ways we can help others join with these activities is to design our systems and processes with participation in mind, but why stop there? We also try to teach, and its a waste to teach someone a proces, and not tie it into a broader understanding.

This interactive talk, derived from the "Desigining for Participation" session at the Mozilla Summit, and spured on by the release of the Web Literacy Standard v1.0, aims to not only help drive better participation by making systems and processes more accessible, but connect skills people learn + use within these to a broader understanding and web literacy.

Pharo3 is close to being released. But development is not standing still: Soon the development of Pharo4 will start. As with Pharo3, the plan is to integrate changes for 10 months with a 2 month bug fix period and a release within one year.

This talk will give an overview of what people are working on for Pharo4. Topics will be - Boostrap from Source - Minimal and virtual images - towards one image file - better model for saving changes - VM level work (e.g. type feedback optimisation)

The Qt toolkit offers a huge amount of cross-platform functionality. Qt can be used in a lot of different ways for game programming, from quickly creating throw-away external debug tools to providing core game infrastructure. This talk will highlight different ways that Qt can make the lives of game developers easier.

Qt contains a huge number of well-tested and cross-platform modules that can be used for game development purposes. Of course, Qt is great for creating level editors and other tools with a nice cross-platform GUI. But Qt can also be helpful in building the game itself, even when the Qt GUI parts are not used.

The QObject system provides ways to give generic access to properties and methods of C++ objects. This can be used for introspection and live manipulation of game objects. With the generic QVariant data type it is easy to make game objects serializable and to give scripting languages like JavaScript access to the game. Other useful parts are the multithreading support, the QML markup language and OpenGL integration.

This talk gives an overview of these different techniques and also discusses issues like performance, memory management, ways of implementing the game loop and integrating various render engines like OSG or Ogre3D.

wikiLingo is a programming environment that is wysiwyg first. It is parsed JIT and creates a sort of DOM that is traversable and modifiable. wikiLingo comes with wiki markup, but it is so much more than that. It is a cross CMS platform for a living whiteboard.

Imagine a living whiteboard, where you could tell the whiteboard you wanted to have a movie, a tabbed interface, a report, and logic, in sort of pseudo way, and the whiteboard do what you want... without ever writing a line of code. Meet wikiLingo.

Why is wikiLingo different?

• Editing: wikiLingo uses html5's contenteditable and complements it with javascript that forces it to act the same in modern browsers, thus limiting the amount of code needed for a wysiwyg editor, because you are using the browser, not a monolithic wysiwyg project.
• Parsing: wikiLingo parses to an object oriented structure, just like a DOM does with html (a POM, or Parsed Object Model). This structure can then be rendered to whatever component is needed abstractly. You want html? fine. wysiwyg html? ok! PDF, sweet! EPUB, no problem. These are abstract layers that can be manipulated at will.
• WYSIWYG HTML: html is seen as a separate item within wikiLingo, although in the wysiwyg output, there are both standard html and wikiLingo markup html, they are treated completely different.
• Drag and Drop in WYSIWYG: CKEditor says this is going to be a very complicated task, and it is like they are doing it. They say you can't nest widgets, they are just doing it wrong. What we have come up with is the ability to insert a drag handle image into the page when wysiwyg is needed, this handle forces the plugin to detach from the page when dragging and is then reinserted where the image is dragged to. By doing this, we have ALREADY SOLVED drag and drop.
• Standardisation: We are already compliant with Drupal, and WordPress, and are brainstorming an easy transition into Tiki.
• Security: wikiLingo parses html tags, and knows which ones are acceptable (this can be changed with events), when a tag is not acceptable, it is rendered in a way that it is safe, and won't be parsed on the client.
• Implementation: wikiLingo is event driven, so ANY system can tap into these events and do things like limit certain plugins for security, only allow certain users to user certain plugins. The sky is the limit.
• CSS and Javascript management: wikiLingo has a css and javascript collector that is used internally, this makes cross platform implementation a breeze!
• Multi Language: It is a very simple event, wikiLingo is easily tapped into to facilitate any language needed
• Roadmap?: wikiLingo is built in php, but it is strongly typed in order for it to be used on other platforms in the future... Like C# ;)
• What is the goal?: To make a wysiwyg tool that a grandma could use.
• But it is programming?!?: Yes but you don't have to code, it is "programming... without".
• I've heard enough, I want to see it! ok:

(please note, the is a preview, the site has not launched yet) http://wikiLingoDoesThat.com/demo/editor.php (a simple editor implementation, highlight some text) http://wikiLingoDoesThat.com/demo/mirror.php (if you actually want to code, here you can) http://wikiLingoDoesThat.com/demo/test.php (unit tests) http://wikiLingoDoesThat.com/demo/compare.php (reciprical wikiLingo to html5 wysiwsyg to wikiLingo test, please ignore the php warnings, we are fixing them)

Github Links: The organization: https://github.com/wikilingo The code, and examples of accepted syntax: https://github.com/wikiLingo/wikiLingo The code wiki: https://github.com/wikiLingo/wikiLingo/wiki The drupal plugin: https://github.com/wikiLingo/drupal the wordpress plugin: https://github.com/wikiLingo/wordpress

Do you need Perl to write a novel? Indeed you don't and many, if not most, novelists write them without using it, and I'm positive about this. However, Perl can help you through the process of writing a novel and that's what I've done with the open source "Manuel the Magnificent Mechanical Man", which you can either buy in Amazon or download as a CPAN module. I'll talk about how I organized the workflow for writing the novel using Perl, Git, GitHub, and the modules and Perl features which helped me through the process.

The MariaDB CONNECT Storage Engine allows access to various file formats (CSV, XML, Excel, etc). It give access to any ODBC data sources (Oracle, DB2, SQLServer, etc). Also, it allows access to remote MySQL tables. A CONNECT table itself can be a set of remote MySQL tables. This opens the door to interesting distributed architectures that can help to address big data. We will show practical examples of how the MariaDB CONNECT Storage Engine can help you get benefits from your existing data sources.

MariaDB storages engines are bringing a lot of value to users: CONNECT is still quite unknown.

• The CONNECT storage engine allows to access various file formats. It also allows to access remote MySQL tables. A table itself can be a set of remote tables. This open the door to interesting distributed architectures.

We will present possible use cases. We will present interesting benchmark results of distributed queries.

When it comes to Big Data with MySQL the answer is not simple and the CONNECT storage engine introduce a new range of possibilities.

Many state-of-the-art graphical applications and frameworks still use direct X11 and legacy GL API calls. As we need to move further and follow new evolutions of the UNIX display stack, especially on embedded platforms, we need to adapt or wrap our codebase to Wayland and GLES.

X has been part of UNIX ecosystem for more than 20 years now ; it will now progressively become “deprecated” in favor of Wayland, which targets both desktop and mobile platforms. On the other hand, while OpenGL has been extensively used will still be, its numerous API evolutions, breakages and target profiles tend to render old code unusable on new implementations, and especially those of current Wayland compositors.

Starting from a practical development case (an application -OpenCPN- using deprecated OpenGL1 calls and a toolkit -wxWidgets- which itself has not been fully ported to Wayland yet), we will describe how we managed to get it accelerated-running on Weston by wrapping :

• X11/GLX and wxWidgets-GDKX calls with our EGLX library ;

• OpenGL 1 calls with the jwzGLES library.

We will finally explain what efforts remained pending to obtain a fully-working port of the application (deprecated concepts in core code, API misuse…) to an embedded GNU/Linux platform.

DIY: Build Linux kernel and Tizen platform image from scratch; create an open-source hardware device powered by SoC with Allwinner processors and boot Tizen on it.

Tizen is an open source Linux-based software platform for multiple device categories such as smartphones, tablets, personal computers, in-vehicle infotainment devices and smart TVs. Tizen is registered trademark of the Linux Foundation and it is governed by a Technical Steering Group composed by Samsung, Intel and other industry-leading companies.

Sunxi represents the family of ARM System on Chip (SoC) devices with Allwinner A10, A10s, A13, A20 and A31 processors. A variety of devices on the market relies on Allwinner ARM processors. Among them are the popular open-source hardware development boards OLinuXino which are designed and manufactured by Olimex as well as Cubieboard by cubieTech.

The talk will discuss the status of Tizen-sunxi - a community-driven project for porting Tizen to Allwinner devices as well as building a Tizen device based on open-source hardware components. The following topic will be briefly covered: * Assembling Tizen device using open-source components * Building Linux-sunxi and u-boot boot loader from scratch * Building Tizen platform image from scratch using GBS (git-build-system) * Preparing bootable Tizen microSD card * Booting Tizen and debugging through UART0

YouTube video of a homemade Tizen tablet: http://youtu.be/vMQmf4hype4

This session will cover the current status of integration between oVirt and the OpenStack image repository (Glance), analyzing the motivations, the low level implementation (including Keystone authentication), and ideas for the future. This presentation will include also an ample part dedicated to the future work and ideas to introduce the integration with Cinder (the OpenStack volume manager).

• Introduction to oVirt Storage Architecture
• Glance Integration Motivations
• Glance Integration Deep Dive
• Ideas and Future Work on Glance Integration
• Future Integration with Cinder
• Roadmap

Distributed storage systems like RozoFS provide the best solution to adapt the resources of your system to an evolving demand, but data protection entails a huge data consumption.

This topic would interest those who cares about the data consumption (which is directly linked with energy consumption and architecture cost) of their clusters.

Erasure coding (EC) is a technique providing the same data protection and availability as traditional block replication, while reducing storage usage significantly (e.g. up to 50%). Of course, EC comes with drawbacks, as it performs complex computations. However, the Mojette transform, used in RozoFS for its erasure code behaviour, brings fast computations since it relies on simple additions. Efforts are done to open up EC-based systems to data-intensive applications.

The growth of the global storage is alarming. IDC's Digital Universe study [1] forecasts that the global amount of data will reach 40 zettabytes (ZB) by 2020. Data protection plays a major role in this storage consumption.

The Mojette transform [2] is a mathematical tool from the University of Nantes that computes 'n' redundant projection blocks from 'k' information blocks. Any 'k' blocks among the 'n' are sufficient to retrieve the original data, behaving like an erasure code. Distributing these 'n' projection blocks over network storage nodes, RozoFS [3] is able to face 'n-k' node failures (including disk, network, server failures). Providing the same data protection and availability as traditional block replication [4], this technique reduces significantly the storage capacity (e.g. up to 50%). Of course, erasure coding comes with drawbacks as it performs complex computations. The Mojette transform, however, brings fast computations since it relies on simple additions. RozoFS holds many important characteristics for a distributed storage system, such as:

• scalability: clusters of storage nodes can be added on demand;
• openness: compatible with different protocols (CIFS,NFS,...), Amazon S3, Hadoop,...;
• transparency: users manage their file exactly as usual;
• management: provide a tool to make the administration tasks easier.

http://www.emc.com/collateral/analyst-reports/idc-the-digital-universe-in-2020.pdf JeanPierre Guédon and Nicolas Normand http://link.springer.com/chapter/10.1007%2F978-3-540-31965-88 http://www.rozofs.com/ Hakim Weatherspoon and John D. Kubiatowicz http://oceanstore.cs.berkeley.edu/publications/papers/pdf/erasureiptps.pdf

A short presentation of the tests the Libreoffice team uses to test import and export filters.

The Libreoffice team uses a number of tests for import and export testing. We will present what and how we use different approaches to make Libreoffice better. As a highlight we will present our script that imports around 45000 documents in various formats and exports more than 60000 documents regularly on a server. Additionally we will show some of the in-build file format testing approaches used in the Libreoffice project.

Generating music from an Arduino usually needs a shield. And shields cost money. This talk introduces a project that makes it free and easy to play sound without a shield, nor a knowledge of musical theory.

We shall introduce a number of projects that make the Arduino make noises, other than the squeaks of the example code. This includes the new library, Armstrong, which supports various methods of playing music, along with MIDI functionality, all from a vanilla Arduino.

The XHTML Export filter in OpenOffice has traditionally been quite limited. In an ongoing project, students are being mentored to integrate work by Habib Louafi based on an older version of OpenOffice into the current trunk. This work adds substantial new features such as: support for fonts, better layout, better support for images, and support for shapes. We will see the technical progress, but also the process with students working in different phases and having to work around licensing issues and dependency issues.

Miracast is the name of a WiFi-Alliance certification program for the WiFi-Display standard. It basically defines a "wireless HDMI-cable" so you can connect monitors via WiFi. Some Android vendors implement it, Microsoft ships it with Windows 8.1 and with OpenWFD we now also have the first Open-Source implementation available. This talk shows what Miracast is, how it works, and how you can use it on your favourite linux distribution already.

The Wifi-Display standard (abbr. WFD) was created to define a common way to connect TVs and monitors to your PC or smartphone. It is not meant as media-file streaming protocol like DLNA, but rather as a "wireless HDMI-cable". It provides only a single video/audio stream from a source to sink, is optimized for low-latency and allows easy setup.

WFD uses Wifi-Direct (wifi peer-2-peer / Wifi-P2P) to create a direct connection between two devices. A mode-negotiation follows and once all parameters are clear, an mpeg stream is established. Several extended features like split video/audio-sinks, enhanced timing-protocols or more are available.

OpenWFD is the first Open-Source implementation of WFD. It is targeted at linux and provides some example source/sink daemons so you can already use it. However, proper integration into the linux software-stack is still ongoing and the final setup will probably differ highly from the current project state.

For many years the Linux distro concept has been about "inclusion of applications" sometimes at the detriment to co-habitating applications and the stability of the core OS. Much discussion has been made over the years about JEOS, embedded Linux, custom distros, applicance building, etc, but not a lot of discussion about how applications could be delivered such that they were more readily able to co-habitate.

Open source applications (because distros are so "inclusive") are put through significant scrutiny around their design and deployment related to their integration with the core OS that may or may not make sense. The scrutiny is certainly more intense than proprietary software is required to undergo. This talk proposes a new'ish technology, Software Collections, as a method for resolution.

Mozilla has participated in the Google Summer of Code every year since it started. This talk will review what Mozilla has gained, show off a few successful projects, and explain the great opportunities to participate for both students and mentors.

From its early beginnings in 1991 as the runtime for interactive television set top boxes to its fundamental role in everything from big data to cloud today, Java's rise has had more than its share of twists and turns. In this session, we'll quantitatively explore the decline of some Java projects against the rise of others. Understanding what Java was, is, and might become will help Java advocates from all areas to better communicate the strengths and future of the platform moving forward.

Even today, in spite of its widespread and evident market success, there are those who would claim that Java is either dead or dying.

Part of the problem, however, may be in outdated perceptions of what Java was versus what it is today. In this session, we'll quantitatively explore the decline of some Java projects against the rise of still others. Understanding what Java was, is and might be will help Java advocates from all areas better communicate the strengths and future of the platform moving forward.

What Java is has changed, and the better appreciated these changes are, the better equipped the Java community is to navigate the years ahead.

Docker is an open source LXC-based container service that was released in March 2013. It makes it easy to create lightweight, portable, and self-sufficient containers. Containers which you can use to test applications, build, and run services or even to build your own platform-as-a-service. Learn why Docker matters, how to get started with it and see some cool examples of Docker in action.

This talk will explain:

• Why Docker?
• Installing Docker
• Getting started with Docker
• Demo some cool Docker use cases

It'll also discuss the right places to use Docker and try to answer some of the questions around using Docker with other tools like Puppet and Chef. By the end of the talk I will demonstrate both how Docker is useful and how to make use of it.

The DeforaOS desktop environment is one of three major components from the DeforaOS Operating System project. It is Open Source and meant to be portable, currently supporting Linux, *BSD, MacOS X, and possibly more. More than just an alternative desktop, it can be adapted for embedded use, be it with a stylus or with finger-based interaction. It has already been released and presented as a Debian-based smartphone (Openmoko) and a NetBSD-based tablet device for instance.

The DeforaOS Project was started in 2005 with one specific goal: seamlessly integrating software on personal devices (workstation, laptop, PDA...), possibly involving the migration of running applications across them. While this is still being worked on (with a working prototype), the development of the project involved a deep understanding of the design and implementation of existing systems. Therefore, a number of components has been developed again from scratch, so as to more easily support the more innovative components.

Doing so quickly highlighted three major parts: a self-hosted environment (libc, basic tools, assembler and compiler), the distributed framework (main objective of the project), and a desktop environment which is what will be presented here. While initially intended to fully grasp the specific constraints of GUI applications when supporting the distributed framework for the DeforaOS Project, it is meant to be fully usable and sufficient for regular desktop use, including a file manager, desktop manager, panel, web browser, e-mail client, telephony application and more.

The DeforaOS desktop is currently based on the Gtk+ toolkit, usually requiring version 2.6 or newer (including Gtk+ 3.0). It can be found packaged for Debian (via the hackable:1 project), FreeBSD (official ports), NetBSD and more (via pkgsrc).

In this presentation, I want to show little-known mechanisms to add hardware support to the kernel at runtime, i.e. without recompiling. After this presentation, the Linux kernel will have gained support for a previously unsupported USB device (without having to write any code).

Not everyone is interested in becoming a kernel developer or being able to write device drivers from scratch. Yet, there are a number of people who would like to help the kernel development "just a little bit". Yay, this is easily done!

I aim to enable people to improve the kernel by adding support for previously unsupported hardware. How? Consumer hardware often shares a common core which is then simply re-branded by the actual vendor. This branding often includes changing the USB-ID or PCI-ID. A kernel developer can make a driver for that core, but will not be able to know all the incarnations of that device, i.e. all the IDs. This is where the community comes in. Having all kinds of hardware, people can add missing pieces to the puzzle.

In this presentation, I want to show some little-known mechanisms to add hardware support to the kernel at run-time, i.e. without recompiling. For that, I will also present ways to effectively obtain the required information about hardware to be added. Finally, information is given how to report the findings.

Intended audience: Everyone who is interested in kernel hacking is invited. Basic shell knowledge (sudo, echo) and ability to send e-mail are enough.

Traditionally, LibreOffice has had an appallingly slow and mis-architected spreadsheet core. Come and hear how we've re-designed it to take advantage of the major wins possible with both GPU and CPU parallelism, and extrapolate that to your application.

Traditionally, LibreOffice has had an appallingly slow and mis-architected spreadsheet core. Come and hear how we've re-designed it to take advantage of the major wins possible with both GPU and CPU parallelism, and extrapolate that to your application. See how Calc can now give you a real appreciation of what a teraflop of GPU computing power can really do inside your workstation, and understand how terrible things used to be.

Hear about the structural challenges that OpenCL and the GPU

brings, and how getting the underlying data structures and design right is the key to better performance. Grasp how the next generation of integrated CPU/GPU hardware with a Heterogenous System Architecture starts to enable efficient crunching of huge data-sets.

We'll also look at how we're starting to use threading to

speed up load/save not just in calc, but also in other parts of the suite. I'll also showcase some of the latest improvements in our FOSDEM release: LibreOffice 4.2.

In the past one and a half years the MINIX team has been working on a port of MINIX 3 to the ARM platform. We now have a port of MINIX 3 to the popular BeagleBone Black.

In this talk I will look back at MINIX 3 on ARM and explain how it became what it is. I will show a few nice features it has, including some stolen from NetBSD and some related to automatic recovery from otherwise fatal system errors.

The goal of the talk is to shine an other light at embedded development and share our experience in this area.

To many developers the database is a black box. You expect to be able to put data into your database, have it to stay there, and get it out when you query it... hopefully in a performant manner. When its not performant enough the two options are usually add some indices or throw some hardware at it. We'll walk through a bit of a clearer guide of how you can understand how database is doing from a 30,000 foot perspective as well as analyze specific problematic queries and how to tune them. In particular we'll cover:

• Postgres Caching
• Postgres Indexing
• Explain Plans
• Extensions
• More

This presentation will talk about hybrid verification, an innovative approach to demonstrating the functional correctness of a program using a combination of automated proof and unit testing.

SPARK 2014 comprises a subset of Ada 2012, excluding those features not amenable to sound static verification. SPARK 2014 uses the contract-based programming provided by the latest Ada 2012 version, and uses the Ada 2012 aspect notation to strengthen the specification capabilities of Ada by the addition of new contracts for data dependencies, information flows, state abstraction, and data and behavior refinement.

Once the functional behavior or low-level requirements of a program have been captured as SPARK 2014 contracts, the verification tool-set can be applied to prove that the implementation is correct and free from run-time exceptions automatically. Only where verification cannot be completed by themselves is it necessary to write unit tests, with the same contracts used to check the correct run-time behavior of the relevant subprograms.

Objective-Smalltalk is a re-imagining of Objective-C for the 21st century. Like Objective-C, it blends features from Smalltalk and C, but instead of adding some Smalltalk features to C, it adds ideas from Objective-C to Smalltalk.

It is intended as a full-stack language capable of complementing or replacing Objective-C for iOS and Mac OS X programming as well as replacing most scripting language use in those environments. It is not Smalltalk-80 compatible.

Presents http://rendering.xwiki.org/ a generic engine for transforming content in a given syntax (mediawiki, confluence, JSPWiki, Markdown, HTML, XWiki Syntax, etc) into an output format (PDF, HTML, XML, etc), applying optional transformations.

This framework is generic and can be used outside of XWiki easily into your own Java applications.

RestFS is an experimental project to develop an open-source distributed filesystem for large environments. It is designed to scale up from a single server to thousand of nodes and delivering a high-availability storage system with special features for high i/o performance and network optimisation for work better in WAN environment. The Project is on the beginning stage, with some technology previews released.

The Restfs is pure-python, but several of the libraries that it depends upon use C extensions (sometimes for speed, sometimes to interface to pre-existing C libraries). The main characteristics of the RestFS are :

• Scalability, no limits on storage and clients size
• High availability, no single point of failure and data replication
• Adaptive, load balancing and uniform distribution
• High Performance, parallel transfer, local cache consistency , data transfer by difference
• Flexible, S3 compatibility interface, dedicated library for integration in web server and application layer

This talk describes the architecture, internals of RestFS and comparison among different free software solutions. The session will discuss our experience in this development and detailed information on performance and scalability

For MySQL 5.7, one of the engineering goals is to continue to clean up and simplify code, and improve the architecture of the MySQL Server.

As part of this spring cleaning process, some features in MySQL 5.7 had a change in behaviour; for example the EXPLAIN PARTITIONS and EXPLAIN EXTENDED syntax will be enabled by default. Other features will be deprecated and may be removed; for example the InnoDB Monitor tables.

This session aims to describe the motivations behind each of these changes proposed, and how they will affect those that administrate MySQL servers.

Qt Creator is a full-featured IDE that can help you with your C++ (and C where that does not conflict with C++) coding -- with and without Qt!

In this presentation I want to encourage all the a-texteditor-is-all-I-need developers out there to give integrated development environments a try.

Using an integrated development environment (IDE) raises your productivity and can make your live as a programmer more enjoyable. This fact is widely known in the proprietary software world, but in the free and open source software world there still is a huge following for programming in a text editor.

This presentation shows why you should not be content with primitive tools and uses Qt Creator as an example to demonstrate what an IDE can do for you.

People keep hearing about A/B testing, but not a lot of people understand it. Rather than focusing on what your software does, it helps you focus on what your customers do. This talk will introduce some basic concepts of A/B testing, explain some common mistakes people make, and (if I'm lucky), will introduce the first open-source A/B testing module for Perl (I've already written it, but it needs to be renamed and have a better interface).

LibreOffice Writer's ODF filter was always capable of remembering attributes of elements which it does not understand, so after a load and save, such attributes were not lost. But what about the rest of the file formats? InteropGrabBag is a new API we have been creating over the past few months that lets foreign filters store their unhandled attributes, so such information is not lost during such a round trip. Come and see where we are, what still needs to be done, and how you can help.

Topics to be covered in the talk include

• Capabilities for mutual exclusion / locking of guest disk images
• Fine grained access control against individual operations, users and objects in the API
• The sVirt mandatory access control framework
• Auditing and structured logging via the systemd journal
• Integration with systemd and cgroups for resource management

In the 8+ years since it has been founded, the libvirt project has grown to become the leading open source API for the management of virtualization hosts, with a strong focus on supporting the open source virtualization & container technologies, KVM, QEMU, Xen and LXC. Many people working in the open source virtualization management space already have an understanding of the core features and architecture of libvirt. This talk will thus focus on a selection of recently developed features and of some of the other important, but less well known, features of libvirt.

The talk will be targeted at virtualization application developers using libvirt, with a bias towards those using KVM or LXC. At the end of the talk the audience will better understand how to take advantage of libvirt for their development needs.

Game programming is so fragile that most new games get written from scratch, again and again. We've created a new game engine for pulling apart games into atoms and stitching them back together in novel ways. Our techniques are inspired by functional programming, reactive programming, and dataflow, but still use imperative blocks that many programmers are familiar with. The game engine is completely open source, as are the games written on it.

We could do it as a talk, or as a tutorial where we show people how to use it.

The project is hosted at https://github.com/CyberCRI/gamEvolve/. We work at the CRI in Paris (http://www.cri-paris.org/).

OLinuXino is Open Source Hardware Linux Computer with ARM processor, this allow people to learn, explore, modify and customize the boards for their own needs and projects. We will demonstrate how easy is to make your own Linux computer based on OLinuXino design.

What is new in the file-format coverage within LibreOffice? Focusing on new improved APIs which will land in LibreOffice 4.3, encouraging details about the growth of filter-writing community.

The talk will focus on the new import filters that entered LibreOffice since last FOSDEM. We will also speak about two new libraries with improved APIs that help filter-writers to generate different flavours of ODF (ODG, ODP, ODS and ODT) in a simplified way. The tools used for reverse-engineering and introspection of files will be also presented.

How to handle metadata in puppet and chef, what are our observed best practices and how to maintain coherency

• Introduction to metadata in chef
• Metadata organisation in chef
• Introduction to metadata in puppet (classic and hiera)
• Metadata organisation in puppet (hiera)
• Bad metadata practices in chef and puppet
• How to enforce good behaviours
• How to avoid brain metadata fragmentation between provisioners and configuration management
• Questions

Moose provides the tools allowing the analysis, visualization and refactoring of Delphi source code.

Android is a popular open source Linux based operating system that has been activated on over 1 billion mobile devices. This talk will describe the evolution of Android's runtime from Dalvik to ART, a new runtime introduced as a developer preview in the 4.4 release.

Android is a popular open source Linux based operating system that has been activated on over 1 billion mobile devices. This talk will describe the evolution of Android's runtime from Dalvik to ART, a new runtime introduced as a developer preview in the 4.4 release.

Wikipedia is supposed to be "the free encyclopedia that anyone can edit". However, from our research we know that that's not really true. The wikitext markup used on most Wikipedia articles has gotten so complex that most people can't figure out how to make changes. To address this problem, the Wikimedia Foundation and Wikia are developing VisualEditor, a new, WYSIWYG-like editor for wiki pages. VisualEditor is already available on Wikipedia, but in this presentation I will show you how you can install VisualEditor on your own wiki and customize it to your needs.

While VisualEditor is primarily developed with editing MediaWiki pages in mind, we deliberately designed it from the ground up to be a generic HTML editor, completely independent from MediaWiki. Our long-term goal is to make VisualEditor the FLOSS HTML editor for the web; to make it so much better than other editors out there that other projects will want to use it too. We're very excited about the prospect of integrating VisualEditor with other applications than MediaWiki, because so many HTML / rich text editors on the web today just aren't things people want to use.

Although the "Modules" system has been around since the early 1990ties it has yet to find widespread adoption outside of the scientific computing and HPC community. Most FOSS developers rely on a wide range of tools to abstract and manage their Linux and UN!X environments for different scripting languages, compiler toolchains and applications. This problem has been long solved in the world of High Performance Computing where optimization of applications, toolchains and libraries is paramount. Environment Modules are a wonderful tool that will save time, help ease of development processes, reproducibility, and management of your development environment. This talk will give insight into how Modules work, which implementations are out there and how to use Modules instead of language bound tools as well as a comparison with common tools that the community uses to develop on Python and Ruby (for example) projects.

I intend to give a 20 min overview of the "Environment Modules" system as deployed on many scientific and HPC sites to FOSS developers, students and linux enthusiasts.

This will include a comparison of different Modules implementations their history and typical use cases in HPC and development environments and how Modules can be of help to FOSS developers and systems administrators. As a developer and systems engineer, I am familiar with a lot of different systems to manage multiple installations of e.g. script languages their environments and libraries. I'll give a short overview and comparison of those and compare these systems with Modules and show how developers and engineers alike can save time and effort in managing their environment for all applications, toolchains and script languages.

Starting with pdf.js, spiraling around shumway & zipfile.js, we'll explore what JS is already capable of, even though it never seemed practical. Then we'll go on to explain the WebAPIs to bring the "native" right in the browser (with a tinge of FxOS - so that it's not up in the air, it's already there - in fact it's so-last-FOSDEM actually). Finally, we will talk about the (near) future, and how broadway.js, asm.js (Emscripten, LLVM) et al. are going the change the web - for good!

The new replication features in MySQL 5.7 help users to further reduce downtime, thus increasing data and service availability. Moreover, they consolidate MySQL as a perfect fit for distributed environments such as elastic clouds.

The most recent Development Milestone Release presents a lot of new and exciting enhancements. Worth noting the latest developments on semi-synchronous replication, multi-threaded slave, and replication instrumentation for accessing internal stats through performance schema tables. In addition, the work done to make replication more scalable, perform even better and be more user friendly also deserves some of the spotlight.

Therefore, don't miss this chance to meet with the engineers behind the product, to get to know the next generation of replication features and to influence future development. Lets talk about MySQL Replication!

Bareos is a reliable network open source software to backup, archive and restore files from all major operating systems. The fork was founded 2010 out of the Bacula project. The fork has been actively developed and many new features have been added. This talk explains the reason for the fork highlights some new features and show community participation options.

Today Bareos comes with LTO hardware encryption, bandwidth limitation and handy new console commands, among other new features. The source is available on Github and is licensed with AGPLv3. There are ready to install repositories for all major Linux distributions and windows installer packages.

Bareos was inspired by the idea to reanimate the Bacula community, in order to pursue development of new capabilities and sustainable ensure it's open source character. Today Bareos is a transparent, high quality open source solution, which is the only one with a comprehensive multi-level support, provided by trained and certified open source professionals.

The presentation will have the following subjects:

1. Open source evolution: reasons for forking and speed up development
2. Some new feature highlights, like passive clients to ease backup of DMZ clients, transparent backup replication 'Backup to disk to cloud', hardware encryption.
3. Stringent open source strategy
4. How to participate

Intents are a way for applications to declaratively describe their capabilities and let other applications invoke it. Sounds simple? It's still not possible today.

LXQt is introducing intents. Inspired by Android's intents, they solve several long-standing issues on the desktop. Best of all, they are being developed as an open spec, so that other DEs can use them.

Intents are the declaration of standardized D-Bus interfaces to a type of application. A demo of their various capabilities will be performed. This talk will also introduce the audience to the related improvements being made to application declaration, invocation, interaction, and integration.

EasyBuild is a software build and installation framework written in Python that allows you to install software in a structured, repeatable, and robust way. This talk will present the problem with building with scientific software, introduce EasyBuild, and discuss the main features of the tool.

EasyBuild is motivated by the need for a tool that allows to:

• independently install multiple versions of software side-by-side
• support multiple compilers and libraries for building software and its dependencies
• keep the software build configuration simple
• divert from the standard configure / make / make install with custom procedures (which is often necessary for scientific software)
• use environment modules for dependency resolution and making the software available to users in a transparent way
• keep record of the installation logs
• keep track of installation configuration in version control

Some key properties of EasyBuild:

• installation configuration is done using a (very concise) .eb specification file
• custom behaviour is described in easyblocks; these are Python classes that can be plugged into the EasyBuild framework
• the generation of the module files to easily make the software available to users
• the dependencies for installation are resolved using environment modules and can be automatically installed using the robot feature
• after the installation, the specification files can be sent to a repository for archiving

In recent years GDB has undergone a renaissance, adding Python scripting and other cool new features. This talk will show you how to customize GDB for your application and your debugging needs. We'll go into depth about pretty printing, stack trace filtering, and writing new commands; and will also discuss writing GUIs and other tools inside GDB. Finally, we'll cover other interesting and useful GDB projects.

In this talk we'll cover:

• A high-level overview of how GDB has modernized in the last few years

• Customizing GDB for your application, using Python:

  • Writing a pretty-printer
  • Writing a stack trace ("frame") filter
  • Writing new commands, functions and other goodies
  • Cool use cases like built-in GUIs

• Other projects to help your debugging

  • Scalability
  • Local/remote feature parity
  • C++ features
  • Multi-inferior, multi-target debugging

Gravel is a modern Smalltalk implementation for the JVM. It's aim is to provide an interactive development environment in the Smalltalk philosophy as well as a stable and fast runtime platform. Gravel aims to be fully ANSI Smalltalk compatible.

(Family circumstances might force the speaker to cancel at the last moment. The time slot would then be used for "Show us your projects" instead.)

Workflow from developer creates a text string, until a released product with n languages.

OpenJDK 8 has required substantial changes to the VM to support the new features in the language. This talk will provide an overview of the modifications required to JamVM to support them. This includes JSR292 (invokedynamic), JSR308 (type annotations), JSR335 (lambda expressions) and JSR901 (method parameter reflection). As of now, JamVM fully supports OpenJDK 8.

CentOS has cemented a reputation as the "community enterprise operating system" - one that provides a reliable rebuild, but is not known for innovation in its own right. With the news that Red Hat and CentOS are joining forces, this is going to change. Here's how CentOS is planning to change, and how other distros can learn from our next phase.

This includes our governance changes, and how we'll address several different special interest groups (SIGs) that have different ideas they want to realize with CentOS. It also includes technical changes, and I'll explain how we're going to manage our build system and source control for accepting upstream code and then creating new variants.

Most importantly, I'll also be taking questions about the new direction and how we got to this point.

Dovecot is an IMAP/POP3 server that can easily run in both tiny installations and in installations with tens of millions of users. This talk explains some methods and design decisions on how Dovecot nowadays does clustering, as well as some problems found on the way there: Proxying, NFS issues, dsync replication, caching, object storage.

Xorg (the X-server) is a big and complex beast. Currently it runs as root as it needs root privileges for various reasons. But with the latest systemd-logind all necessary infrastructure is in place to allow the server to run as a normal user and use systemd-logind to do input and graphics device management.

This talk looks at the work being done to leverage this new infrastructure to run Xorg without root rights.

This talk should appeal to curious developers interested in learning about OpenStack development and why contributing to it is a smart, interesting, and simple move. Although familiarity with open source development is assumed, no previous knowledge of OpenStack itself is necessary.

OpenStack is a software stack written in Python that you can use to deploy public and private "Infrastructure as a service" providers, potentially at massive scale. This talk will look into why contributing to OpenStack should be interesting to you personally, where in the various pieces and teams of OpenStack you should consider helping, what various shapes your contribution to OpenStack may take, and finally deep dive in the details of our development infrastructure and how you can actually make your first contribution.

A tutorial on how to use the Ada 2012 features for specifying detailed, checked contracts for types and subprograms -- "classes, functions, and methods" if you aren't an Ada programmer already.

Contracts document constraints on how types and subprograms behave, but unlike comments they are checked -- either by when the program is compiled or on-the-fly as the program is running.

Ada 2012 contract aspects will be presented together with a set of guidelines for using contract aspects consistently. The tutorial will conclude with a live test of the guidelines on some example source text.

In recent years, Postgres has gone beyond a traditional database and has become more of a data platform. While keeping its roots as a robust RDMS, it has added flexible, friendly document storage, and more.

We'll take a tour of features which make Postgres a compelling choice for your next project, including

• Embedded JavaScript and JSON
• Other Extensions and Datatypes
• Window Functions
• Accessing non-postgres data like Redis, Mysql, and even Mongo

The goal of this talk is to provide information about Xen on ARM project and encourage hackers to port their OSes as ARM guests.

Xen recently supports ARMv7 and ARMv8 platforms, such as the Arndale Board, Midway, Cubieboard... With the new Xen architecture for ARM, porting your OS as a guest is easier that you might think. It will allow your guest to be shared on your virtualized ARM server. This session will focus on requirements and what needs to be done in order to get your OS working as a guest. Examples will be provided about how we ported FreeBSD to run as a Xen ARM guest.

Topics which will be covered:

 * Xen on ARM architecture
 * Prequisites to boot an OS as Xen guest
 * What was modified in FreeBSD ARM core?
 * What about BSD as DOM0?

Jan-Simon Möller will introduce the audience to the LLVMLinux project which goal is to compile the Linux kernel with the compiler tools provided by the LLVM project (clang). He will talk about the steps needed to compile the Kernel itself, the issues found during this endeavour and the status of upstreaming the patches to the Kernel and the LLVM project.

The first version of the Fiduciary License Agreement was published by the FSFE in 2007 in order to offer something that was missing at that time — a well balanced copyright assignment for the FS community.

Since then different FS projects have made use of it. Some to assign copyright to FSFE and others to assign it to different entities in order to take care of paperwork and copyright issues for the FS project.

In this presentation we will look at the lessons learnt in the diverse history of the FLA and look ahead what is in line for the next version of the FLA.

The Fiduciary License Agreement [FLA] is a very well balanced copyright assignment that is beneficial for both organisations that foster FS project and the contributors.

Its main goals are to: - make sure the project stays Free Software; - make license maintenance easier for the Fiduciary (the entity); - retain as much freedom and power to the Beneficiaries (the contributors) over their own code as possible not to make the software non-Free.

After a short introduction, we will look at how FSFE and other entities — from dedicated FS organisations to businesses and individuals — have made use of the FLA and which lessons were learnt in those 6 years.

At the end of this session we will peek into the future of the FLA and discuss improvements aimed at the next revision.

Servo is a brand new browser engine being written by Mozilla Research, Samsung, and members of the Mozilla community. It's built in Rust, a new programming language created by Mozilla, and designed to take full advantage of modern hardware and security practices. Come learn about what sets Servo apart from the competition, and how you can contribute!

In the beginning of the great kingdom of the Internet, there was one ruler: Perl. With time, fallen from grace, the beautiful princess language lost its place on the throne, giving way to Ruby, Python, and to the dismay and horror of everyone in the kingdom, PHP.

But all is not lost. While underground, Perl has schemed a plot to overthrow the competitors. That plan is Plack/PSGI.

Interested in knowing more? Attend the talk, if you dare!

In this talk, I'd like to walk through some of the more technical parts of SailfishOS (www.sailfishos.org). Recently, Jolla (www.jolla.com) has shipped a mobile device based on the typical GNU/Linux stack together with new technologies such as Qt5 and Wayland. Information is presented such as how factual contribution to the open source parts of SailfishOS is done, with projects such as Mer Core and Nemo Mobile in the picture plus a walk-through of some of the more exotic pieces such as the ability to leverage Android hardware adaptations for Wayland based systems, through libhybris.

Saltstack is arguably one of the best of the "new breed" of configuration management solutions. In this talk, Corey takes the audience through a stand-up of a Salt environment and leads into some examples of how you can leverage the message bus to automate not just configuration management, but your entire infrastructure.

Corey will show you how his sausage is made...

Built with simplicity and speed as its overarching design goals, Salt has taken the configuration management world by storm over the past three years. Built atop a zeroMQ based message bus, realtime analysis of your existing environment, and rapid deployment and orchestration of your entire environment are now within reach. In this talk, we'll go through an initial setup of Saltstack in a lab environment, investigate signal passing from one node to another, and demonstrate how Salt can orchestrate entire environments both simply and effectively.

Global Transaction IDs (GTIDs) are a new feature of MySQL 5.6 that can ease failover. Discover the benefits and challenges of GTIDs.

Replication has been used for a long time to provide high availability. However the traditional position-based replication has a serious drawback: a same transaction will never have the same position on two different servers. Reconfiguring replication is then difficult and error-prone, which is bad when you want to make failovers as graceful and reliable as possible.

Enter MySQL 5.6 and Global Transaction IDs (GTIDs): a transaction is guaranteed to have the same identifiers across all servers of a given replication topology. This opens up new ways to handle failover, for instance when used in combination with Oracle's MySQL Utilities.

But are GTIDs ready for production usage? How do you set up GTIDs and the MySQL Utilities to provide high availability and automatic failover to your replication cluster? What are the limitations of the MySQL Utilities? How do they compare to existing tools, for instance with MHA which is a robust and widely used tool?

Come to this session to get a sense of the benefits and challenges of the high-availability solutions available with MySQL 5.6.

ODF 1.2, additionally to the fo:language and fo:country attributes, introduced fo:script and *:rfc-language-tag attributes to allow for the full range of BCP 47 language tags. This talk will give a brief overview what it means to applications and how LibreOffice implemented it and the consequences it may have for extension developers.

Ubuntu, through Unity is tackling the convergence topic between multiple form factors. We will expand the past and future evolutions throughout that goal.

This talk is about presenting how Unity was built and its history through the Ubuntu Netbook Remix to become the default on this distribution desktop flavor. We will discuss what to expect as well for the next Unity desktop version and how Mir and the newly Unity8, based on Qt and QML, was needed for the phone flavor. The different technologies and a demonstration of the current progress will close the talk before opening to a QA.

In this lightning talk, we would like to share our experiences regarding a couple of software engineering tools we wrote. Those are all based on syscall instrumentation, and they are daily used in an industrial environment:

1. PRoot is initially a user-mode implementation of some kernel features: chroot, mount --bind, binfmtmisc, ... Its original purpose is to build and to validate programs on systems that are supposed to be not compatible (distro, kernel, CPU, ...). PRoot does not require any privileges since it relies only on ptrace, processvm_[read|write]v, and seccomp-filter to observe and modify syscalls between programs and the kernel. With time, PRoot has become a generic Linux process instrumentation engine, used by the two following tools.

   -- http://proot.me, GPLv2+

2. CARE -- short for "Comprehensive Archiver for Reproducible Executions" -- creates automatically an archive that contains all the material required to re-execute the monitored programs in their original context (environment, files, expected kernel features, ...). CARE is typically useful to get reliable bug reports, demonstrations, academic experiences, tutorials, ...

   -- http://reproducible.io, GPLv2+

3. DepsTracker observes the execution of any processes in order to compute their mutual dependencies with respect to the file-system. It is currently used to re-generate highly parallel build-systems that are then dispatched by another tool on build-farms, in order to find the best performance by brute-forcing compiler internal configuration.

   -- not published publicly, GPLv2+

HPCBIOS is concerned with the ability of users to handle tasks across computational platforms (HPC, Grids, Clouds) uniformly and painlessly, as much as technically feasible.

The aim of this work is to present ongoing efforts and concepts tried in centers located in the EU & US, trying to streamline the user experience in scientific computing, as well as, probe the interest of the community for current needs and future work.

Points to be considered include:

• Aspects of computational infrastructures that puzzle or delay scientific users
• Common Applications or Tools that are needed and, categories thereof
• Logical organization of software environments, modules technologies and status
• Common Failure Modes which may be encountered/avoided on scientific platforms
• Which software code helps in the above topics and where/how to contribute to it
• Feedback by the audience, current challenges

MADE (Massive Artificial Drama Engine for non-player characters) is a procedural content generator (PGC), with stochastic generation and modelled as a generate-and-test algorithm (search based) that performs the optimizations of the process during the game development (offline). It presents an environment where many characters interact to generate plots where complex behaviors can emerge. Currently, an article about MADE is being evaluated by the committee of the Evostar 2014 (European conference on the applications of evolutionary computation).

Ji Gong project focuses on empowering JVM technology and guaranteeing its availability. Ji Gong discusses deployment of a minimal and efficient JVM on all platforms including web browsers on mobile devices. Ji Gong re-purpose and utilizes existing work, e.g. IcedTea-web, OpenJDK 8 and FOSS JVM implementations such as JamVM. We will showcase deployment of SCC signed applications using JogAmp APIs running on top of Ji Gong within a browser on embedded devices and desktop.

Ji Gong implements Source Certification Contract, SCC, to verify binary object's. When attempting to run a binary object on your system, users need to trust the binary and its original source code. The question should ask for the authorship of the binary and it's assumed source code, hence SCC authenticates the binary against the source code it claims to be originated from. We will showcase deployment of SCC signed applications, using JogAmp APIs running on top of Ji Gong within a browser on embedded devices and desktop.

The important work which no one wants to pay for.

Razor is a flexible open-source provisioning tool that makes it easy to control how machines are built based on rules and policies. It maintains an inventory of nodes and their hardware characteristics, gathered by booting each node into a discovery image. Discovery information, together with user-defined policies is used to make installation decisions.

Razor can install a wide variety of operating systems, from common Linux flavors like Debian, Ubuntu, CentOS, and RHEL, to operating systems known for their resistance to automated installation like ESXi and Windows. Beyond installation, Razor strives to be a tool for managing a machine's lifecycle, including power control via IPMI etc. and easy integration with external systems.

Razor is an opinionated tool that focuses narrowly on provisioning, but makes it easy to hand off a node after installation to a configuration management system like Puppet to perform more complicated setup tasks and for ongoing maintenance. This talk will give an overview of Razor's capabilities and provide some hands-on examples about its use; it will also give examples of how Razor and Puppet can be used to address common provisioning problems, like building an OpenStack cloud.

h264, MPEG LA and patents.

Recently, Cisco released a software component for H264 video support under the BSD license. This would normally be considered Free Software, except for the fact that this standard is considered to be patented (where software patents apply). They are covering the MPEG LA licensing fees, but only for pre-built binaries, not for the corresponding source. I will discuss this issue, and why the resulting software is not only non-free, but does not solve any issues for distributors with a focus on Freedom (such as Fedora).

Now that <audio> starts to get traction on the Web, let's talk about the new API authors can use to make noise in their web pages.

We will briefly cover the API, and then show what is possible to achieve with it (and what is, at the moment, hard or impossible) and how it fits in the Web platform. We finish with possible plans for future of the API.

ROS is an open software integration framework for robots that is becoming more mature day by day.

Spider is a storage engine for database sharding for MySQL/MariaDB. Spider is already bundled in MariaDB 10.0. I will introduce Spider and new topics.

Database sharding is the technique of splitting huge datas, a horizontal partition a database or search engine. Each individual partition is referred to as a shard or database shard. Spider Storage Engine enables tables of different MySQL instances to be treated like a table of a same instance. Because XA transaction and partitioning is supported, it can do decentralized arrangement to two or more servers of data of same table. If your database is growing, you need considering to make sharding into multiple servers for splitting data and request. This session is for introducing database sharding especially database level sharding. In addition, some other plugins are convenient by combination with Spider. Spider is a unique and useful plugin of MySQL for database sharding such as a Storage Engine.

Foreman is a complete lifecycle management tool for virtual, cloud, and physical servers. Through deep integration with configuration management, infrastructure services, and PXE and Image-based unattended installations, Foreman manages every stage of the lifecycle of your servers. Foreman provides comprehensive, auditable interaction facilities including a web frontend and robust, RESTful API.

Managing what actually runs on your instances could at times be tricky in large dynamic environments, in this talk, we'll introduce Foreman which can help managing your datacenter and cloud infrastructure, making it a perfect hybrid cloud management tool.

Foreman is a life cycle management tool for servers, helping to provision (integrates with many virt and cloud providers - openstack/ovirt/libvirt/ec2/gce/rackspace etc) and to define their purpose in life, their content (e.g. package versions, configuration etc) on an ongoing basis.

Foreman is already 4+ years old, and deployed at many small and large scale organizations, and is a used in distributions such as RDO and RHOS (redhat version of openstack distribution).

Foreman provides comprehensive, auditable interaction facilities including a web frontend robust RESTful API and CLI, which makes building higher level business logic on top.

With Foreman you could:

• Discover, Provision and upgrade your entire baremetal infrastructure (e.g. build up an openstack cluster or your favorite pets)
• Create and Manage instances across baremetal/virt/cloud infrastructure (openstack/ovirt/libvirt/ec2/gce/rackspace etc).
• Group your hosts and manage them in bulks regardless of location
• Review historical changes and stuff to look at when something goes wrong
• Extend as needed via a robust plugin architecture.
• Automatically build images(on each platform) per system definition to optimize deployment.

Listaller is a new approach for making 3rd-party software installations on Linux possible, without interfering with the native package manager. Listaller's primary focus is system-integration, so users will not notice that they are using the tool, as it integrates with existing PackageKit-based software management frontends. The installer also contains a new approach to dependency-handling, and makes use of existing specifications, such as AppStream.

Software management on Linux is traditionally done using packages, although Linux desktop users are more interested in applications instead and do not care much about how something is packaged. Also, users often want to install software which is not available in the repositories (e.g. new applications or new versions of them), without having to upgrade the whole distribution. Listaller extends the package manager with the ability to install 3rd-party applications. It is built on top of the AppStream specs and PackageKit and focuses on system-integration. This means no additional UI must be added in order to install applications packages using Listaller. Listaller apps can be managed using existing tools like GNOME-Software or Apper. Because software from 3rd-party sources is a potential security risk, Listaller also tries to give users a hint if they can trust a certain application, and makes it possible to run these applications in a sandbox automatically. For developers, it contains some helper tools to make applications work on multiple distributions.

Ero.Coli retraces the journey of a nano-robot in its quest of ensuring the balance and prosperity of their living world.

This project is a single-player 2D top-down adventure game where the hero, a tiny nano-robot, has to explore a living world, collect, and combine functional DNA fragments in order to engineer and control the abilities of his bacterium companion and face obstacles and dangers.

This project is based on three main axes: - This game should allow players to understand the basics of synthetic biology, popularise the open BioBrick system - see biobricks.org - Players will have the opportunity to play with DNA fragments to create their own abilities, and, in the long haul, participate digitally in research, or even in our wet labs - This game will be a real gaming experience: fun and engaging

Automatic Testing of Installed Software is a testing framework to validate the various flavors of software installed on an HPC site. It is composed of a set of unit tests, a runtime and a result-gathering dashboard. These tests are user-oriented as they assess the basic features that a general user expect to work on an HPC platform.

Currently, it only focuses on generic MPI functionality as it is one complex and critical component of an HPC platform, but it will be extended to compilers, libraries and performance validation and regression in the future.

HPC centers tend to provide a wide choice a software. Different users requires different software, but also different versions of the same software. Combined with the different compilers, MPI stacks, library dependencies, there is an explosion of software flavors installed on an HPC site.

Tools already exist to help managing this large variety of software. Users can choose their software through the software list using the 'module' system. Administrators can perform automatic compilation and installation of software using EasyBuild. Additionally, software also require some customizations on some HPC sites. Thus, software flavors need to be validated after installation to check they're working as expected by the users.

We developed and provide a set of unit tests together with a runtime and result-gathering framework to perform a such Automatic Testing of Installed Software. These tests take the side of the users in order to test any basic feature that a general user expect to work on an HPC platform. So far, the proposed tests only focus on generic MPI functionality as it is one complex and critical component of an HPC platform. The unit tests include, for example, compilation with mpicc and distributed execution with mpiexec. It has been applied successfully on the HPC platforms of the University of Luxembourg to assess builds of OpenMPI, MPICH, MVAPICH2 and IntelMPI generated with EasyBuild.

In the future, we consider extending our unit tests to validate more components like compilers, libraries, toolchains and even applications. Another future direction is to consider performance validation and regression.

This talk will start at the basics that any programmer in any language will need to know, moving on to Perl's approach to Unicode and its gotchas. To keep things interesting there will be a short puzzle to figure out every few slides. Some of them will be testing if you've been paying attention to the previous slides, and some of them will be trick questions which will be explained subsequently. See if you can get a perfect score!

An introduction of how to create new panels for the OpenOffice sidebar.

Creating new panels for the OpenOffice sidebar is easy once you understand which steps have to be taken and why they are necessary. There are three different aspects:

1 The UNO API of OpenOffice 2 The general structure of addons. 3 The additional requirements of the sidebar.

This talk will skip the first, mention the second and focus on the third.

As you may or may not be aware, Fedora is transitioning from its classic "one-size-fits-all" approach to one where we intend to target three specific user types with individual products: Fedora Workstation, Fedora Server and Fedora Cloud. Gathering Fedora contributors at FOSDEM to work on the logistics around this change in direction would be a valuable opportunity.

If you have an idea for how to improve Fedora or how to make one or more of the three new products really stand out, please join us for this planning and working session for Fedora's future. The Fedora.NEXT effort was launched recently as a means to reinvigorate interest in this most storied of distributions. We know that this will only succeed if we are meeting the real needs of our users, both current and potential. We would like anyone with an interest in guiding Fedora towards being the best solution for them to join us for this discussion.

General presentation of the Tizen project and how to interact with it at the application or core level or even for designing your own Tizen system.

Tizen is a Linux Operating System for phones, vehicles, and other devices. Talk will give a short introduction to the project and focus on how can any developer interact with it.

Application level:

• Creating HTML5 apps with W3C + tizen APIs
• Creating native apps in C++ using Tizen Osp API
• Creating hybrid apps

Platform/distro level:

• Bug reporting / submitting patches
• Building packages
• Workflow Integration in the project

Profile / Hardware level:

• Create a new profile
• Adapt to unsupported hardware
• Rebuilding your own image

Spoon on the Raspberry Pi.

Explains how the XWiki software is developed on all aspects:

• Governance
• Build process
• Release process
• Communication tools
• Code quality
• xwiki.org vs xwiki.com And more...

In the 15 years since its initial release, the Postfix mail system has become a significant component of the email infrastructure. As the system became more feature-complete, the focus of development has moved towards making the system more extensible and more resilient in the face of changing threats. I will present lessons learned and recent developments, including some new features in this year's release.

Software developers rely on a fast and correct build system to compile their source code changes and produce modified deliverables for testing and deployment. The scale and complexity of the PostgreSQL build process makes build performance an important topic to discuss and address.

In this talk, we will introduce a new build performance analysis technique which identifies "build hotspots", i.e., files that are slow to rebuild (by analyzing a build dependency graph), yet change often (by analyzing version control history). We will discuss the identified hotspots in the 9.2.4 release of PostgreSQL.

After a quick reminder of the Hoare Logic and the approach for designing software by contracts, the tool suite developed by AdaCore for formal verifications is presented. To make the concepts easily understood, a little program simulating a sandpile is used.

Despite a decade of innovative development, and despite improvements in battery technology, a modern smartphone needs recharging far more often than its turn-of-the-century predecessor. Yet the blame cannot be laid at the door of hardware engineers; the problem lies in the software. Fortunately free and open source technology is racing to the rescue. With this talk we aim to promote energy efficiency to a first class software design goal.

Modern silicon chips are able use very little power. Multiple clock domains, clock gating and dynamic voltage and frequency control have all served to make modern hardware highly energy efficient. Yet all that can be destroyed by the software running on the chip. In this presentation we will look at how the entire software design process needs reworking to bring the software engineering team into low power design from day one. Central to this is the availability of good software development tool support, debug functionality, and energy transparency from hardware to software. We will explain why developers should consider energy consumption as a primary design goal for software, give an insight into how energy consumption of code can be measured and present some of the tools we are currently working on to enable more energy efficient software development.

Open source is playing a central role in giving developers access to tools that enable energy efficient design. We will present details of MAGEEC, a UK government funded project to build the next generation of open source machine learning compilers, which will optimize for energy efficiency. We will present the compiler framework, and the energy measurement hardware, both of which are fully open source. We will also introduce the EU ENTRA project, which aims to promote energy aware system development by enabling energy transparency from the hardware to the software in a computer system. This will be achieved using advanced energy modelling and program analysis techniques to make predictions of energy usage available to the system developer and to the software engineering tool chain. We will present energy consumption analysis tools developed in the ENTRA project.

The talk leads into the Energy Efficient Computing devroom happening on Sunday.

Due to a cancelled flight, Keith is not able to make it to FOSDEM this year. This talk will therefor not be taking place.

The X Composite extension opened up a wealth of possibilities for enhancing the free software desktop, however it came with a cost in performance and power -- extra memory used by applications and extra copies of that memory from application buffers to the screen. This presentation will describe and demonstrate enhancements to the Present extension which can eliminate most of these additional copies, and with suitable kernel and application changes, eliminate even more copies for non full-screen double buffered applications.

On the Free Software implications of JavaScript.

JavaScript served to you by a site is still software. It runs on your local computer. Typical computer use for just about everyone involves executing copious amounts of JavaScript on a daily basis, no matter what operating system they are using. The vast majority of it carries no license or copyright notice at all, often because of concerns about optimizing bandwidth and speed. This makes it proprietary for the users who receive and execute it in their browsers, even if the source code is available elsewhere on the Internet in some repository under a free license. The Free Software Foundation has proposed and implemented a couple of licensing metadata methods by which JavaScript which is intended to be free software can clearly say so, and therefore actually respect the freedom of its users. This is the first step in compliant and realistic distribution of copyleft-licensed JavaScript, as well as a step toward allowing free software users to run only free software inside the browser as they do outside the browser. Other approaches have been proposed as well. What are the advantages and disadvantages to each? Why has JavaScript licensing been such a problem in general? What are the concrete impacts of this phenomenon? We will discuss these questions and seek input on the FSF approach so far.

The new FreeBSD 10.0 has been released just before FOSDEM. This new release adds many new features and enhancements to FreeBSD.

To tease your appetite, here are some of the highlights:

• FreeBSD now includes the BSD native hypervisor bhyve.
• The build system now uses the CLANG compiler instead of GCC by default.
• The ports and packages system now uses the new PKGNG package repository by default.
• A new kernel-based iSCSI target and initiator have been added.
• FUSE is now part of the base system which allows you to run nearly all fusefs filesystems.
• Growfs can now enlarge filesystems while mounted.
• A new and better implementation of the CARP protocol.
• The PF packet filter now supports fine-grained locking which significantly improves performance on multi-core systems.
• More GNU utilities replaced by BSD licensed implementations.

Write once run anywhere is both a blessing and a curse. For years, the WORA promise has ensured a consistent, compile-free experience for JVM users. Unfortunately, sometimes pure-Java libraries just can't do what developers need done. Sometimes, you just have to go full native. The Java Native Runtime is a core library and suite of support libraries for binding and calling out to native code. I'll show how JNR is designed, compare code and performance with alternative approaches, and talk about why the JDK needs a standard FFI (foreign function interface) in Java 9.

Write once run anywhere is both a blessing and a curse. For years, the WORA promise has ensured a consistent, compile-free experience for JVM users. Unfortunately, sometimes pure-Java libraries just can't do what developers need done. Sometimes, you just have to go full native. The Java Native Runtime is a core library and suite of support libraries for binding and calling out to native code. Without writing a line of C, you can make native calls, pass callbacks, and manage off-heap memory; every OS, library, and kernel-level feature is available to Java developers. I'll show how JNR is designed, compare code and performance with alternative approaches, and talk about why the JDK needs a standard FFI (foreign function interface) in Java 9.

Initially inspired by the proprietary software Prezi, Sozi is a free and open-source "zooming presentation" tool based on open standards. This talk will expose the general concepts of Sozi and how it benefits from the use of open standards, from a user's as well as a developer's point of view. We will give an overview of the current status of the project and the expected future developments.

Over the last few years, several presentation tools have emerged that provide alternatives to the traditional desktop slideshow software. Some of them, like reveal.js, allow to create slideshows using web standards such as HTML5, CSS3 and JavaScript. Others, like the proprietary software Prezi, have set a new paradigm based on a sequence of camera movements (translations, zooms, rotations) over a single, unlimited canvas where all the visual content of your document is laid out.

Initially inspired by Prezi, Sozi is a free and open-source "zooming presentation" tool based on open standards. A Sozi presentation is an SVG document augmented with presentation data and a player script in JavaScript. As a consequence, such a document can be played directly by any standards-compliant web browser without the need to install a plugin or a specific viewing software. For presentation creators, we have chosen to build the Sozi editor as an extension to the free SVG editor Inkscape. Sozi is open to contributions: volunteers have provided translations to 8 languages, others have created packages for several widely-used GNU/Linux distributions.

While the tool is used on a daily basis by teachers and researchers, several issues prevent a wider adoption:

• On the editor side, the usability of the user interface needs to be improved but is constrained by the Inkscape extension system.
• No one has volunteered to create installers for Windows and OS X, so users of these operating systems must install all dependencies manually.
• On the player side, poor SVG rendering performance in some browsers can make the animations jerky for complex documents that contain gradients and bitmap images.

To address the first two issues, we consider the possibility to create a new editor using web technologies. The current form-based UI would be replaced by direct manipulation and live preview, allowing significant improvement of the user experience. Moreover, the use of JavaScript would allow to share code between the editor and the player.

However, while Sozi has been mostly the work of a single developer working on his spare time, creating a new editor and integrating new features will require the constitution of a real development team.

The Firefox Developer Tools team has been working hard over the last two years to provide web developers with useful, performant developer tools in Firefox. These tools are now excellent and are receiving a lot of attention from web developers. We have always thought that in addition to being useful and performant they also need to be extensible so that add-on hackers and web developers can create their own customized tools and provide better support for specific web frameworks and technologies.

The Firefox Developer Tools team has been working hard over the last two years to provide web developers with useful, performant developer tools in Firefox. The tools are now excellent and recieving a lot of attention from web developers. We have always thought that in addition to being useful and performant, in order to be Firefox they also need to be extensible so that add-on hackers and web developers can create their own customized tools and provide better support for specific web frameworks and technologies. This talk will cover the current apis and techniques used to extend the developer tools, how to get started, where to find help and real-world examples.

Notes for developers to get accessibility right in dialogs for LibreOffice when using the new UI format. How to convert existing accessibility relations in old code into the new XML descriptions. How to set mnemonics and why it is important. How to tweak containers to enhance accessibility.

MySQL Fabric is an open-source solution released by the MySQL Engineering team at Oracle. It makes management of MySQL server farms easy and available for both applications with small and large number of servers.

In order to provide resilience to server failures, MySQL Fabric organizes the servers in groups and deploys high-availability solutions within each group. The concept is independent of the implementation, which can be done using traditional asynchronous primary backup approach, MySQL Cluster or solutions with shared or replicated storage. In the first version, availability is implemented using the asynchronous primary backup approach.

As the enterprise grows, so does the data and the number of requests for the data. A single server will not be able to handle the increased demands on size and load of the database. A common technique for scaling is to shard the database thereby reducing the write load and data size for each server. MySQL Fabric is integrated with the connectors and provides an enhanced API for working with massively sharded databases.

In this presentation, you will get an introduction to MySQL Fabric and how it support high-availability and sharding as well as how to write and manage applications taking advantage of the latest features of MySQL Fabric.

Scalasca is a comprehensive open source performance analysis toolset for parallel programs, built with the aim of helping developers to identify opportunities for optimization. It covers all steps of performance analysis, from code instrumentation, measurement, and analysis to the visualization of the results.

Scalasca can be used with parallel codes of any size, from multicore machines to the fastest supercomputers in the world. It supports MPI and/or OpenMP libraries. It supports Blue Gene, Cray XT and Linux clusters.

Scalasca combines runtime summaries suitable to obtain a performance overview with in-depth studies of concurrent behavior via event tracing. The traces are analyzed to identify wait states that occur, for example, as a result of unevenly distributed workloads.

The new version of Scalasca is based on the community instrumentation and measurement infrastructure Score-P. This improves interoperability with other performance analysis tools, by the use of the Open Trace Format 2 for event trace data, and CUBE4 for application profiles.

CUBE is the interactive analysis report explorer GUI for Scalasca. Its color-coded scheme makes observation of timing phenomena straightforward.

The talk will introduce the main components of Scalasca to the audience.

Topics will cover:

• Examples of delays caused by imbalances
• Propagation effects of such imbalances
• How to spot these events in GUI

After the audience understands why the imbalances exist, a quick how-to follows, showing

• Instrumenting the code
• Measurement
• Analysis
• Evaluation

Hawaii is a Wayland and QtQuick based desktop environment with few dependencies aiming at desktop and mobile convergence. It is primarily used by Maui, a Linux system with atomic upgrades and bundles. This talk introduces the project to those who don't know it yet, presents the progress that have been made and future directions.

Traditional desktop systems with mouse and keyboard have different requirements compared to mobile platforms with touch input. With QtQuick, desktop and mobile convergence becomes easier to implement not only for applications but also within desktop environments. Hawaii is designed from the beginning to have different UX for different needs. The Hawaii desktop environment is part of the Maui project. Maui is a Linux system aiming at improving user experience with atomic upgrades and bundles instead of packages, but can (and it's encouraged to) be packaged for other distributions. This talk introduces the project to those who don't know it yet, presents the progress that have been made, and future directions.

OSv is a new open source operating system for the cloud. It is designed to run a single application per virtual machine and its tuned for applications running under the Java virtual machine.

In this talk, we will introduce OSv, showcase its architecture, and explain performance and application management improvements. We will also talk about OSv specific improvements to the JVM that improve application performance in virtualized environments.

Operating system developers, as well as application developers who deploy to the cloud, may enjoy the talk. No special expertise is required.

• Why do we need a Cloud Operating System?
• OSv design overview
• JVM optimizations for OSv and the cloud
• Management
• Performance
• Future

MATE Desktop is a fork of GNOME 2. It provides an intuitive and attractive desktop to Linux users using traditional metaphors.

MATE Desktop is a fork of GNOME 2. It provides an intuitive and attractive desktop to Linux users using traditional metaphors. The talk introduces MATE to those who haven't heard of it, explains the reasons of its birth, explains the difference with GNOME Classic and GNOME Flashback sessions, describes the features and changes added after the fork and shows the current roadmap for the future versions.

Come and hear how you can re-use LibreOffice's powerful functionality in a variety of settings: for document indexing, headless on a server, file format shifting, charting, and more.

LibreOffice has a ton of interesting and useful functionality, and a supposedly wonderful abstract component model. However in-practise re-using it for different purposes than a PC office suite is a real pain. Come and hear how we're overcoming this in various ways. Hear about our command-line format conversion avoiding remote control RPC issues. See how you can use liblibreoffice to bring a complete libreoffice into your process without a dependency and linking nightmare. Hear about our new tiled rendering and how it can be applied to new user interfaces.

With the rise of GitHub and the recent move of the Eclipse foundation to a social coding model, more and more people are wondering why participation in OpenJDK isn’t keeping up with the times. A small group of people from the London Java Community (LJC) and Adopt OpenJDK are trying to solve this problem by building Betterrev, a platform that will reduce barriers to entry for participation in OpenJDK: our intent is that all attendees will be excited by the potential benefits that the social-coding philosophy could bring to OpenJDK.

With the rise of GitHub and the recent move of the Eclipse foundation to a social coding model, more and more people are wondering why participation in OpenJDK isn’t keeping up with the times. A small group of people from the London Java Community (LJC) and Adopt OpenJDK are trying to solve this problem by building Betterrev, a platform that will reduce barriers to entry for participation in OpenJDK and also improve visibility of contributions.

This presentation will highlight our motivations for the Betterrev project, the primary goals (and proposed roadmap), and our current progress. Our intent is that all attendees will be excited by the potential benefits that the social-coding philosophy could bring to the OpenJDK, and will be encouraged to generously volunteer their time and skills to help push the development of Betterrev forward, with the ultimate goal of creating a highly social ecosystem around contributions to a free Java.

Which of your daily programming or system analysis and design activities aren't attempts to find and choose the best way to do something - an activity in which computers and automation are, in the long run, far superior? Learn to do those things instead of doing the things machines can do better than you.

Over the last 15 years, GPUs have gone from being a piece of hardware found almost exclusively on the machines of gamers to being present in almost every single desktop and laptop computer. This hardware presents opportunities to greatly improve power usage and performance for graphics applications. Over the last 5 years GPU utilization in the desktop application world for accelerating 2D graphics has slowly moved forward, however their intended use for video games also presents us with a number of limitations.

Over the last 15 years GPUs have gone from being a piece of hardware found almost exclusively on the machines of gamers, to being present in almost every single desktop and laptop computer. This hardware presents opportunities to greatly improve power usage and performance for graphics applications. Over the last 5 years GPU utilization in the desktop application world for accelerating 2D graphics has slowly moved forward, however their intended use for video games also presents us with a number of limitations.

In this presentation I will talk about what GPUs are, why we want to use them, in what different ways they can be put to use, and some of the challenges we've encountered when using them at Mozilla. I will also try and touch on some of the technical details on the different tradeoffs that the most common algorithms present.

Learn how to use a smalltalk system.

In this talk I'd like to show a live demo covering status of Foreman and Chef integration and try to answer the question "where do we want to get"? Also I could sum up what's needed to add similar support for config management tools of your will.

Fostering an environment where user-developers are enabled and encouraged to automate and interface with our wikis with their code has allowed their productivity and impact to be greatly increased, has stimulated development work on the core code itself, and has allowed the establishment of a vibrant ecosystem of open source development around our projects.

In this presentation, I show what measures we took to stimulate that ecosystem and what lessons we learned about the impact it has on vitality of the developer community of our projects.

This talk introduces the xpcc framework for efficient object-oriented programming for micro-controllers.

Originally developed by the Roboterclub Aachen e.V. for the Eurobot competition, xpcc became a separate project in 2009 and since then focussed on a new approach to cross target microcontroller libraries. It stands out for its extensive use of static C++ classes and templates which is unusual in this field, but lends itself well to the static nature of embedded development. The main goal of xpcc is to provide a simple API which is efficient enough to be deployed on a small ATtiny, yet powerful enough to make use of advanced capabilities found on 32bit ARM Cortex-M.

The xpcc library main features are:

• efficient object-oriented C++ API,
• support of AVR and ARM Cortex-M based micro-controllers from Atmel, NXP and ST,
• build system based on SCons and Jinja2 template engine,
• cross platform peripheral interfaces: Gpio, Uart, I²C, Spi, Can,
• write once, run anywhere external IC drivers using these interfaces, and
• lightweight, non-blocking workflow using timers and cooperative multitasking.

Writing parallel versions for shared memory multi-core computers with Ada tasks requires minimal modifications of the original source code. For pleasingly parallel computations we experienced almost optimal speedups. If we can afford to spend the same amount of time as one core, then we can ask how much better (e.g.: how much more accurate) we can solve a problem with p cores. This leads to the notion to "quality up". Similar to speedup factors, we can compute "quality up" factors.

In this talk we report on our coding efforts to write multi-core versions of the path trackers in PHCpack, a free and open source software package to solve polynomial systems. We started investigating the use of multi-threading to compensate for the overhead of double double and quad double arithmetic.

PHCpack is a software package to solve polynomial systems with homotopy continuation methods. The Ada 83 code of version 1.0 was archived as Algorithm 795 by ACM Transactions on Mathematical Software in 1999. Version 2.0 was rewritten using concepts of Ada 95. Multitasking was introduced in version 2.3.45. Its current version 2.3.84 is available on GitHub.

PHCpack relies on two external software packages: (1) the QD library of Y. Hida, X.S. Li and D.H. Bailey for double double and quad double floating point arithmetic; and (2) MixedVol by T. Gao, T.Y. Li and M. Wu for a faster mixed volume computation. The advantages of double double arithmetic are its simple memory management (a double double is stored in the same way as a complex number) and its predictable cost overhead (just as complex arithmetic). In joint work with Genady Yoffe, we experienced that on 8 cores may already be sufficient to compensate for the cost overhead caused by double double arithmetic.

As computers become more powerful and larger problems lead to more propagation of numerical errors, it may well happen that double double arithmetic replaces common double precision arithmetic.

It is a typical day at work when suddenly someone notices that the application loads slow. They immediately switch to complaining about database performance and demand that you find the problem and fix it. But how to verify the problem is really with the database? What are the common symptoms and where to look for them? And how to isolate the culprit?

The session will discuss the practical approach to troubleshooting performance problems in MySQL: where to start the investigation, what information to look at and how to interpret it. I will also be talking about useful tools and preparing the environment for effective troubleshooting.

Sniper is a performance modeling simulator. The goal of Sniper is to provide software developers with an easy way to analyze their applications. We provide both performance and energy/power analysis, as well as advanced visualization support.

This talk will cover the basics of how to download Sniper and get started quickly, but more importantly show the benefits that simulating your application can provide. With per-function, detailed simulation analysis, CPI stacks over time and energy stacks, software developers that would like to optimize their applications can now do so quite easily and with more insight compared to using performance counter metrics typically available on machines today.

• Downloading Sniper
• Using Sniper
• Visualization and Power Overview

The intended audience is both HPC and scientific software developers, but is also applicable to software optimization in general.

DoudouLinux is a computer environment focussed on children fulfillment, ease of use, security and mastering digital tools. DoudouLinux want to compete with gaming consoles, TV and tablets, as early as 2 years old. After few explanations about the project itself, a live demonstration will show you how it is designed, its functionnalities and the proposed activities.

DoudouLinux is a community initiative dedicated at giving children digital tools favoring self-fulfillment and not alienating, as well as the desire to take back full control over the digital tools that will shape their future. By placing children and parents at the center of the project concerns, DoudouLinux stresses ease and pleasure of use, security or even absolute respect of privacy. DoudouLinux wants to show children the best information technologies, in full confidence.

With more than 75 applications that cover education, creative activities, entertainment and culture, DoudouLinux give children the opportunity to discover many facets of computers in order to stimulate their curiosity, their learning potential and their creativity. Its interface, rethought from ground up, targets the simplicity of a gaming console without sacrificing essential functions. Come and discover it live!

With a wealth of more than 100 contributors, DoudouLinux is being translated into more than 40 languages and its website saw more than 400.000 visitors coming from the 4 corners of the world since the beginning. After 3 years of existence, the pedagogical usefulness of DoudouLinux is approved by teachers since it is already in use in many nursery schools. Nevertheless the project is still starting out and bursting with ideas that just need new contributors to come to life!

The KDE software has been built on Qt since its birth, but often we've needed to create libraries on top of Qt to solve our needs. This ended up being a huge project that was both hard to maintain and a huge dependency, especially on embedded platforms.

The situation has evolved, we moved as much as we could to Qt and we split the features we have available when it made sense. Now we offer a lightweight set of frameworks on top of Qt that will help you make applications with the power of Qt and the KDE Frameworks combined.

How many ways to interoperate? Build bindings to libraries in-process. Build bindings as RPC wrappers. Build bindings as web service wrappers. Build bindings as cross-VM sharing. OR build bindings to a VM which has bindings to all the others.

Use Eclipse and CDT to improve OpenOffice development.

Many features of an IDE like code assist/completion, refactoring, exploration of type hierarchies are common place for languages like Java. For C++ and especially for such a large and complex project as OpenOffice these features where not easily available. Or so I thought. With recent versions of Eclipse and CDT and with proper organization of OpenOffice modules it is possible develop more easily and more productively than with mere command line interfaces.

With addons tailored to the needs of OpenOffice development the whole development cycle of editing, building, deployment, testing (debugging to some extent) can be done from within Eclipse with just a few key presses.

I will describe - how to set up Eclipse to handle the huge codebase of OpenOffice - some of the highlights that Eclipse and CDT bring to editing source code - how to build and deploy code changes

There is a new hat in Debian, bearing the flattering title of "Debian Contributor". Everyone who contributes to Debian is entitled to have it, and gets it automatically. It is a way to give due credit to all manners of contributions to the project. It is a way to make all the energy that is poured into Debian visible. I will show the reasons behind the idea, and how contributors.debian.org works. I will show how it may change the way we perceive Debian, and very much for the better.

Some scientific research problems inherently suffer from an NP-complete problem. This session will explain several meta-heuristic algorithms which can handle such problems in reasonable time.

This session will also do lightning introduction of OptaPlanner, an open source Apache licensed Java library, which implements those algorithms.

Specifically, these algorithms will be explained:

• First Fit
• First Fit Decreasing
• Hill Climbing
• Tabu Search
• Simulated Annealing
• Late Acceptance

PostgreSQL Europe's Annual report will be presented along with other announcements, and the results of the 2014 board elections revealed.

IPv4 has run out.

This talk will show one of the cleanest, and future-proof, ways to enable legacy connections to the legacy IPv4 Internet while ensuring you, your hardware, and software, are ready for the technology of the year 1998 (seriously): IPv6

Mailpile is the new kid on the block in the world of F/LOSS e-mail clients. This talk introduces Mailpile from a F/LOSS hacker's perspective, going briefly into the motivation of the project before delving into demos and technical implementation details.

Mailpile is a Free and Open Source Software e-mail client which raised over $163,000 USD last September (on IndieGoGo and Bitcoin) to support development of the first version of the software.

Mailpile is built around a powerful search engine and uses web technology for the user interface, hoping to rival GMail and other popular web-mail services when it comes to both usability and speed. The project places a strong emphasis on privacy and decentralization and is integrating GPG encryption as a core feature of the user interface. Written in Python and using modern web technology for the user interface, Mailpile aims to very accesible and easy for F/LOSS hackers to tweak and explore.

This talk will serve as an introduction both for potential end users and for folks interested in helping us reboot the world of Free Software e-mail.

MyKolab.com was originally announced for FOSDEM 2013 and saw great response from many people in the community. Planned as an enterprise platform for SMEs as well as collaboration platform for people who prefer to be customers, not products, its focus saw a dramatic shift when Edward Snowden released the PRISM revelations. Georg Greve will share the story on what's behind MyKolab, how it is part of the Free Software ecosystem by design, and how the team experienced the months of ever-new revelations that brought lawyers, journalists and many others into the platform.

Middleboxes are both crucial to today's networks and ubiquitous, but embed knowledge of today's protocols and applications to the detriment of those of tomorrow, making the network harder to evolve. While virtualization technologies like Xen have been around for a long time, it is only in recent years that they have started to be targeted as viable systems for implementing middlebox processing (e.g., firewalls, NATs).

Can they provide this functionality while yielding the high performance expected from hardware-based middlebox offerings? In this talk Joao Martins will introduce ClickOS, a tiny, MiniOS-based virtual machine tailored for network processing. In addition to the vm itself, this talk will hopefully help to clarify where some of the bottlenecks in Xen's network I/O pipe are, and describe performance improvements done to the entire system. Finally, Joao Martins will discuss an evaluation showing that ClickOS can be instantiated in 30 msecs, can process traffic at 10Gb/s for almost all packet sizes, introduces delay of only 40 microseconds and can run middleboxes at rates of 5 Mp/s. The audience is anyone interested in improving the network performance of Xen, including improvements to the MiniOS and Linux netfront drivers. In addition, the talk should interest people working towards running large numbers of small virtual machines for network processing, as well as those involved with the recent network function virtualization trend.

The outline of this talk and goals for this session:

• showing a new use-case for virtualization, targeting virtual machines as replacement for hardware middleboxes
• requirements and our solution to this problem
• what is Click and how we program middleboxes in Click
• what is ClickOS and our contributions
• network processing under XEN, and bottlenecks in the I/O pipe
• how packet processing performance was improved
• initialization, memory usage and synchronization between backend/frontend
• delay and throughput evaluation using high numbers of VMs
• performance of some middleboxes (load balancers, firewalls, intrusion detection systems, etc)
• conclusions and remarks

QtCreator gained the ability to talk with these really small ARM Boards with CortexM processor. This presentation will show how easy it is to get into development on these boards with a GCC toolchain, OpenOCD and QtCreator with BareMetal plugin.

The presentation will walk through all the needed parts needed for embedded development with an CortexM4 ARM processor. The talk focuses on OpenOCD in combination with the BareMetal and QbsProject Plugin of QtCreator. OpenOCD is an opensource hardware debugger which as multiple backends for different debugging hardware. QtCreator is a powerful IDE which has all the bells and whistles of an IDE. It is the main develoment IDE for the Qt toolkit and has a focus on C++ and C development. QtCreator is based on plugins. The two new plugins used in this presentation is the BareMetal plugin for talking with the OpenOCD (or other gdbserver based) hw-debugger and the QbsProjectmanager which is the new qbs build system based software builder based on JavaScript project descriptions. There will be a live demonstration of using an STM32F4 board.

Movit (the “Modern VIdeo Toolkit”) is a high-performance, high-quality, open-source library for video filters, running on the GPU. Come see what the future holds when open-source video editing steps into 2014!

Movit contains everything you need and expect for basic video filtering requirements (scale, blur, sharpen, mix, overlay, simple color grading, and others). Movit is supported in MLT, has full support in Shotcut and is on track for Kdenlive support.

In this talk, I'll talk a bit about:

• What does Movit do, and what doesn't it do?
• What do we mean by “high-performance”? Why the GPU?
• What do we mean by “high-quality”? How hard can a blend be anyway?
• What goes on behind the scenes in Movit's filter graph?
• How do you embed Movit in your own application?

There will also be a demo of Movit in action, and of course Q&A if time permits.

This talk is not about a specific component or a small part of using Puppet, but about a complete workflow on a Puppet infrastructure design that is easy to collaborate on, well-structured, and safe to use.

Target audience: Puppet users with prior experience, but the basics are covered quickly as well.

How to set up a manageable Puppet infrastructure, using 100% opensource tools. All talks that I've seen are about specific components, this talk/demo is about how to combine them to get a Puppet environment that is easy to collaborate on, well-structured, and safe to use.

The demo shows the setup, including the workflow with Git-Flow, Gerrit. It also shows some common design problems and their solutions.

Detailed instructions on configuring the environment that is demonstrated and the workflow can be found on http://puppetspecialist.nl

Christopher Allan Webber of GNU MediaGoblin discusses the past, present, and future of free network services.

Issues of network freedom have gained much attention over the last six years, and increasingly so both within and outside of the software freedom communities. Progress has been made, but present adoption shows we seem to have a ways to go.

What opportunities and challenges face free network services? Ranging from licensing decisions, technical choices, protocols, deployment configuration, and how we message ourselves, many components inform the past, present and future of this field. Join Christopher Allan Webber of GNU MediaGoblin in talking about what can be done so that network freedom can be something that everyone can feasibly enjoy.

Wikidata is a new Wikimedia project that builds a free and open knowledgebase of structured data for Wikipedia and the world. We want to take a look back and talk about what we learned while building the project and take a look at what is coming in the future.

Wikidata is a new Wikimedia project that builds a free and open knowledgebase of structured data for Wikipedia and the world. The development started 2 years ago. Since then the project has grown rapidly. The project has taken off, a large community has gathered around it and a diverse 3rd-party ecosystem around it is growing. We want to take a look back and talk about what we learned while building the project and take a look at what is coming in the future for Wikimedia's shooting star.

A summary of 3 years of heavy lifting of the ports tree, and what is coming next: cross compilation, sub packages, requires/provides and more.

Poor interoperability between browsers is one of the main frustrations faced when trying to develop for the web platform. Solving this is essential for safeguarding the future of the open web, and requires a comprehensive web platform testsuite that is run by all browser vendors. The challenge of creating this test suite is being coordinated by the W3C under the "Test The Web Forward" banner. In this talk, I will present the current state of the test suite, how Mozilla are using these tests in their automated testing infrastructure, and explain how to get involved with improving the web by contributing to the testing effort.

The JDK 7 Updates Project in the OpenJDK Community has been around for more then two years, breaking a new ground in how JDK updates are made and trying out a few new things in the process. This session will go into lessons learned from producing updates to the JDK as part of an Open Source project.

The JDK 7 Updates Project in the OpenJDK Community has been around for more then two years, breaking a new ground in how JDK updates are made and trying out a few new things in the process.

This session will go into lessons learned from producing updates to the JDK as part of an open source Project. Some of the new things worked, while others required some tweaking. I'll cover lessons learned on a broad set of technical issues, from forest and repository management, tagging, development processes & transparency to release management and communication.

AWS is a framework that allows web servers to be written entirely in Ada. This presentation shows the main principles of AWS, emphasizes how Ada features can be used to make servers more secure and immune to buffer overrun attacks.

In large organizations there is a need for central configuration management of desktops, including LibreOffice deployments. The new Windows registry configuration backend allows integration of LibreOffice into Windows Server environments. LibreOffice can be configured with Group Policy Objects. Under Linux, configuration packages can be managed with Remote Root, which is an easy to use, new open source central management solution for Linux (or other package based) systems. This talk will show how these tools work.

There are excellent Enterprise software which are able to scale out and boost performances of a cluster, but none open source. ProxySQL is a new proxy (currently under development) that aims to become the first open source proxy in the MySQL ecosystem able to provide HA and high performance with no changes in the application, using several built-in features and integration with clustering software.

Features under development are: - read/write split ; - queries caching ; - queries filtering and rewrite ; - logging ; - transparent reconnect ; - connection pooling ; - built-in key/value storage ; - integration with clustering solution like MHA for planned and/or automatic failover; - support for master-slave setups (MySQL replication) or multi-masters (NDB or Galera) .

The project is currently under active development, its source code and a mini how-to is available at https://github.com/renecannao/proxysql , and some initial benchmark are available at http://www.proxysql.com

The battle for Wesnoth is in the rare position of being an open source game project featuring many different translations for its huge amount of content. Currently Wesnoth features 54 translations of which 15 translations of the stable series are more than 90% complete.

This session is about sharing the history behind this and factors which can help projects gain a stable internationalization community. The talk will focus on best practices which have shown themselves as working nicely for getting the translation community started as well as keeping translators happy. It might also show how the translation process is connected to the release cycle and what common problems for game translations are.

Net::LDAP is a great LDAP client API, managing standard LDAP operations (add, search, bind, modify, ...), and extended operations and controls (VLV, password policy, change password, etc.). It also includes an LDIF API which is very useful when managing mass import/export between directories. This talk will present basic concepts of LDAP, the Net::LDAP module, and some real life examples.

Workshop for questions related to GDB usage and strategies, and outreach from the GDB community to developers in the field of open document design and implementation.

A debugging workshop for open document developers. Both Openoffice and Libreoffice (and others) are large and complex programs, and we in the GDB community would like to help you, listen to your issues, and try to make life a little easier. The purpose of the workshop will be open. There is no talk. The content will be lead by the people in the room. We in the GDB community want to listen to your concerns, and help you achieve the goals that you wish to achieve in your development life-cycle.

We show general purpose GPU computing using Google's Go language together with minimal use of Nvidia CUDA. This unusual match can perform very reliable, high-performance scientific computation using surprisingly brief and clear code.

GPU-accelerated scientific computing is gaining popularity because of its high performance. Often, nvidia's CUDA toolkit is used together with C/C++. Although undeniably popular, subtle or hard-to-debug issues commonly pop-up. This is especially problematic in a research context where correctness should be the main priority and where we don't want to spend most of our time with low-level debugging.

In this talk we present our uncommon and quite novel approach of pairing google's Go language on the CPU with minimal CUDA on the GPU. In this way we developed an open-source (GPLv3) GPU-accelerated simulation package using about 5x less code than a version using C++ and python, and running about 100x faster than a state-of-the art CPU implementation. The Go+CUDA combination is highly type-safe and memory safe, concurrent (GPU-CPU parallelism) and relieves the programmer from most of the GPU's typical memory management and synchronization issues.

Outline

• Brief introduction to Go and CUDA
• Our Go GPU libraries (BSD-licensed)
• Nearly overhead-free and type-safe GPU memory management
• Automated unit testing of GPU code
• Brief demonstration our open-source software simulating a byte being written by a hard disk head. (shown live in an HTML5 web GUI, provided by an HTTP server embedded in the simulation software)

Intended for researchers using scientific GPU computing. Illustrates how Go can be used in conjunction with CUDA. What to expect/not to expect from Go+CUDA.

In this talk I’ll briefly compare the approach to External Node Classification (ENC) of Puppet and CFEngine, and then describe a very simple yet powerful approach that has so far allowed Opera to cope with a sudden increase of managed nodes.

Classification in Configuration Management is the process of defining common traits of the managed systems (the classes), and tying classes and systems together. Classes collect nodes together in broadly defined sets: in each class most of the nodes share exactly the same traits, and different settings are applied to different classes of nodes.

A node can be managed effectively only if it can be tied to the classes that describe its features, thus making classification a critical process. As all critical processes, classification either scales with the infrastructure or becomes a hindrance to its growth.

Settings are supposed to be homogeneous across all systems in a certain class. However, there are nodes which are part of a class, and yet need some special settings that are different from all (or most) other nodes in the same class. One can well say that exceptions are actually the rule. If classification is critical, to be able to cope with exceptions efficiently in the classification process is crucial.

It’s easy to understand that a simple “internal” node classification done in the tools’ configuration files does not scale (for many reasons), and that other ways must be found to connect together a scalable and manageable “classification database” with the Configuration Management tool of choice: you need “external” node classification to scale.

Configuration Management tools acknowledge this need; for example: Puppet provides “plugs” in its configuration to get classification information from an executable program, and it has done so for ages. That sprung a large ecosystem of ENC tools, where hiera is a popular choice. What about CFEngine?

Thermostat is an awesome platform with the focus on Java Virtual Machines monitoring. This short presentation will discuss what has been done in the past two years until the release of Thermostat 1.0 and its current features and will disclose some spoilers on the future of Thermostat.

Thermostat is an awesome platform with the focus on Java Virtual Machines monitoring. With the recent release of the 1.0 version, developers have finalised the plugin API, allowing external contributors to write new tools on top of the platform. This short presentation will discuss what has been done in the past two years until the release of Thermostat 1.0 and its current features and will disclose some spoilers on the future of Thermostat.

wolfSSL, author of the open source CyaSSL embedded SSL library has made significant progress in 2013 towards bringing the community a more usable, feature-rich, and better supported library for use in an ever-growing range of embedded platforms and environments.  This talk will provide an overview of technical progress in the last year and news on the current state of wolfSSL.  Details on what's new include the addition of new crypto ciphers and algorithms, better hardware cryptography support, more flexible abstraction layers, a JNI wrapper, new platform support, and better development tool integration.

Most of us are aware of the shocking statistic of 'Men vs Women' ratio in the Open Source world. The tough job right now is to find the reason for this shocking difference and figure out ways to get more women involved in Open Source. Being a woman in the Open source world, I have analyzed a few reasons for this scenario. This lightning talk will let me share my views with others and in turn will help me get a more global view point.

I would like this session to be as interactive as possible. The slides used will be simple and I will try not to throw any technical jargons at the crowd.

Hatta Wiki is one of the many small wiki engines that use a version control system repository for storage of their pages. I want to talk about the benefits and drawbacks of using a repository instead of a database, and about different approaches to doing that.

KDE Connect tries to create a network of "KDE Connect"-aware devices that will enable interaction among them by means of compatible services. This talk will explain why we created yet another universal service provider, what is the current status and where we want to go.

The free software workspaces have been trying to integrate with other platforms for years, we can find examples of integration for: Windows (ActiveSync, Samba), OS X (bonjour, AFP), Palm (Pilot) and various standards like UPnP. Each of this bits of integration works in a different way, making it hard to make it all work in harmony and most of them are specific to a service.

KDE Connect takes a new approach: it tries to create a network of "KDE Connect" aware devices that will enable between them compatible services all designed to be simple, functional and easy to use for both, developer and user.

During this talk I plan to explain:

• the reasons why we came to develop KDE Connect (why yet another universal service provider was needed for us)
• its state, including a demo if wifi is working
• imminent future and where we want to go

This session will be about benchmarking MySQL and disk IO subsystems with sysbench and interpreting the results. In our consulting company, I helped a reasonable number of customers with sysbench so I know the common caveats most people run into. This talk will cover benchmarking IO subsystems with fileio tests, as well as benchmarking MySQL.

OpenOffice has a huge and old code base. When working with it one all too often stumbles over parts where knowledge of some code's unmangled commit comments, the motivation behind a change, the caveats surrounding it, references to issue numbers, its relationship with other source files, or its relationship with other issues would be very useful. Some of this knowledge is still available but many pieces were almost lost in each major change of the repository. Using GIT grafts allows to revive that old history as well as possible in only one revison control system: Git.

OpenOffice has a code history of over 25 years. Its proprietary ancestry in the form of revision control system and issue trackers are gone for good, but the almost 14 years of progress as open source are available. Over time different revision control systems were used: CVS, Subversion, Mercurial, Subversion/GIT for AOO/LO.

Fortunately tarballs of the CVS repository were published and archived, the Subversion server supported svn syncing and much of the Mercurial history could be salvaged. For each of these sources it was possible to create GIT imports, the lingua franca of revision control systems. Using git grafts it is possible to stitch these old histories together which makes it much easier to research the code.

Gadgets are very useful and a time saver. In this talk, I will show some of very useful and necessary gadgets that may be less known. Gadgets make editing and reading task very easy. I will show few gadgets that really make great impact on reading as well as editing stuff.

For several years now, the oVirt project has been leveraging KVM and relevant technologies (ksm, etc) in data center virtualizations. Being a mature and feature reach, oVirt takes another step forward with introducing a Pluggable Scheduling API. This presentation will review recent oVirt improvements in the areas of VM scheduling. The first part will discuss the architecture of the new scheduler. In the second part we will show samples of VM scheduling plug-ins, and integrate it to a live setup.

Wikis have been evolving dramatically in the past few years and they are no longer the first generation wikis we used to know like Wikipedia. This session will be an eye opener showing all the capabilities of the next generation wikis. Examples will be mostly from XWiki open source project usages in the wild (http://xwiki.org).

Advances in C++ have gathered momentum with C++11 and forthcoming C++14, and compiler writers busy to keep up. However, for reasons of cross-platform, cross-compiler, aging baselines, etc., the LibreOffice code base is still mostly stuck with C++98. We will discuss how to overcome blockers in adoption of modern C++ features and in what ways LibreOffice would benefit from them.

The Open Microscopy Environment (OME) is an open-source software framework for addressing informatics challenges in biological imaging and analysis: proprietary file formats, lack of storage, and analysis facilities and standards for sharing image data and results. The Java-based OMERO client-server platform and its model-based architecture is applicable to a range of imaging domains, including light and electron microscopy, high-content screening, and recently into applications using non-image data from clinical and genomic studies.

Despite significant advances in biological imaging and analysis, major informatics challenges remain unsolved: file formats are proprietary, storage and analysis facilities are lacking, as are standards for sharing image data and results. The Open Microscopy Environment (OME) is an open-source software framework developed to address these challenges [1]. OME has three components—an open data model for biological imaging; standardised file formats (OME-TIFF) and software libraries for file conversion (Bio-Formats [2]); and a software platform for image data management and analysis (OMERO [3]). In this presentation, we discuss the design and use of OMERO.

The Java-based OMERO client-server platform [3] comprises an image metadata store, an image data repository, visualization and analysis by remote access, enabling sharing and publishing of image data. OMERO.grid [4] facilitates distributed computing including scripting facility for image processing. OMERO.grid manages processes across nodes, providing distributed background processing, log handling, and several other features, using ZeroC’s IceGrid framework [5]. Several third-party applications use the OMERO API (e.g. image-based searching, tracking and automatic image tagging; sophisticated image analysis modules [6]). OMERO’s model-based architecture has enabled its extension into a range of imaging domains, including light and electron microscopy, high-content screening, and recently into applications using non-image data from clinical and genomic studies [7].

Our next version, OMERO-5 improves support for large datasets, and reads images directly from their original file format, allowing access by third-party software. OMERO and Bio-Formats run the JCB DataViewer [8] online scientific image publishing system and other institutional image data repositories [9], [10].

In recent years, we've seen many advances from typical imperative configuration of Linux distributions to more sophisticated declarative configuration systems. NixOS takes a different path to achieve declarative configuration than current widely used state-of-art configuration management systems. By redefining how we package software today using Nix package manager, Linux distribution is configured stateless without examining current state of configuration on the machine.

During the talk, we'll be looking at concepts behind NixOS stack and I'll show some real world examples of usage.

Following technologies will be presented:

• Nix, a purely functional package manager. This means that it can ensure that an upgrade to one package cannot break others, that you can always roll back to previous version, that multiple versions of a package can coexist on the same system, and much more.

• NixOS, a Nix-based Linux distribution. Thanks to Nix, it supports atomic upgrades, rollbacks and multi-user package management, and it has a declarative approach to system configuration management that makes it easy to reproduce a configuration on another machine.

• NixOps, a tool for deploying NixOS machines in a network or cloud.

When developing a web application, the traditional way is to develop the application from scratch using a general purpose language such as PHP, Grails, Play, Java/JSP, etc.

This presentation will show that a next generation wiki (examples based on XWiki: http://xwiki.org) can be used as a web development platform to develop applications on top of it, providing a strong infrastructure scaffolding to building web applications.

The advantages are similar to those of using an application sever. However whereas an application server offers technical services only, a wiki platform offers higher level services such as content management, rendering, storage, WYSIWYGeditor, user management, and a lot more.

Not only are these services offered, you can develop using them in your traditional IDE or in the runtime, directly in wiki pages. This allows developing web applications extremely quickly, collaboratively and with a fast turnaround time, which is perfect for adhoc web application development.

Presenting the currently available OpenPandora handheld, which is a miniature PC with Gaming controls running Linux, to interested people. Additionally, there will be a sneak peek into the future, maybe already with some hardware to demonstrate.

As any other production environments, in order to maximize availability, VoIP platforms have to be fault tolerant. This presentation focuses on solving the various VoIP distribution and replication issues by using the latest additions in the OpenSIPS SIP Proxy.

OpenSIPS (Open SIP Server) is a mature Open Source implementation of a SIP server. As a SIP proxy/router, is the core component of any SIP-based VoIP solution. With a very flexible and customizable routing engine, OpenSIPS unifies voice, video, IM and presence services in a highly efficient way, thanks to its scalable (modular) design.

When talking about a large number of customers / calls, using a distributed architecture is a natural way to go. First, you would want to cover the entire map in order to provide the best quality everywhere to the customers. Secondly, you would want to have multiple points of presence in order to be able to spread the load from the global pool of customers. Last but not least, redundancy is a mandatory requirement for any VoIP platform, both within the same Point of Presence, and also at a geographically distributed level.

The latest additions in OpenSIPS make it an excellent choice for the core server of a distributed and highly available VoIP platform. OpenSIPS has support for a large variety of NoSQL backends that can be used to share data between different OpenSIPS instances ( MongoDB, Cassandra, CouchBase ). Furthermore, several mechanisms are in place that allow for real-time call information replication between two or more OpenSIPS servers, allowing for hot backups to be deployed, which ensure instant call recovery in case of failures, with 0 down time.

In this session, we'll answer "how far along is Perl 6" by exploring the things you can do with Perl 6 today. Along the way we'll discover a powerful way to parse, composable concurrent programming, a rich and extensible object system, and much more.

Five of our speakers from the Legal and Policy Issues devroom have agreed to participate in a governance best practices roundtable. These practices may touch on contribution policy, review boards, policy manuals, licensing tools, trademark guidelines, etc.

Questions will be asked of the panelists to start the roundtable and the audience will also be encouraged to participate in order to have more interaction with the panelists. Karen Sandler will be the moderator.

Using the new Lightbeam add-on for Firefox, we will monitor web-tracking and discover solutions to protect ourselves.

An open Q&A session with members of the OpenJDK Governing Board.

The GNOME Foundation and the KDE e.V. are the governing bodies for the GNOME and KDE project, respectively. Their roles are to find funds to enable creative hackers to do a great job at creating awesome Free Software for everyone.

We want to shed light into the inner workings of the GNOME Foundation Board of Directors and the KDE eV Board, not only to give you information about how we work, but also to demystify the ivory tower we're sitting in.

This talk will be about the principles of GPU offloading, how it is handled with X DRI2, and how we decided to handle it on Wayland.

It's been about 3-4 years since first experiments on GPU offloading on X were done. How is GPU offloading handled with X ? And how the different design of Wayland could influence the way it's handled ?

In this talk, I'll present:

• the technical difficulties involved in GPU offloading.
• how X DRI2 handles GPU offloading.
• What choices we made when designing Wayland GPU offloading support.
• The work that has been done, and what is remaining to do for a better user experience.

This presentation explains and demonstrates how the Fedora Linux distribution can be used for developing in the Ada language. Available tools and frameworks will be demonstrated.

So far the main workhorse database for OpenStreeMap data was PostgreSQL/PostGIS. With the GIS improvements in latest MySQL and MariaDB releases, especially having true spatial relationship functions instead of just max bounding rectangle (MBR) based ones, have become viable alternatives though. This talk is going to present the most important improvements, a MySQL backend for the osm2pgsql importer tool, and some sample applications including performance comparisons.

A short update on the current state of Ada in Debian and the plans for the next stable release which is due early 2015.

Upipe is a brand new flexible dataflow framework. It is primarily designed to be the core of a multimedia player, transcoder or streamer. The framework organizes the processing of incoming data in buffers inside a pipeline of modules. It exposes core types for buffers and modules (called "pipes"), and the API for communication between pipes and between the application and pipes. This presentation will show how developers can take advantage of Upipe to build complex processing pipelines.

LibreOffice now uses a purely GNU make based gbuild build system, where do we get from here?

Now that we can leave behind the artificial restrictions of the old system, while enjoying the opportunities of the freedoms gained with the new system, we can reap what we sowed: IDE integration, reliable incremental builds, sensible splitting of the build for packaging and building a directly runnable relocatable product without additional copies are a few benefits we already achieved. More will soon join these, making it even more "ridiculously easy" (Karl Fogel) to build and develop LibreOffice.

This talk will introduce the architecture of Jailhouse, describe typical use cases, demonstrate the development progress on a target system and sketch the project road map.

The Jailhouse project provides a minimal-sized hypervisor for running demanding real-time, safety or security workloads on fully isolated CPU cores aside Linux. In contrast to other commercial and open source hypervisors of similar scope, it is booted and managed via a standard Linux system. Its focus is on keeping the core code base as small as feasible, generally trading simplicity over features.

Jailhouse has been released under GPLv2 and is being developed in an open manner. The talks aims at attracting further users and contributors, specifically from the embedded domain, but may also trigger discussions about additional use cases.

• motivation & use cases
• architecture and design principles
• current state
• short demonstration
• outlook

A short overview of the Ada compilers and packages available on FreeBSD, NetBSD, and DragonFly.

What happened to the Thunderbird Project since the last version completely done by Mozilla staff. How things are going and what the plans are for the next version.

I'll give an overview of the project and will hold a Q&A cession.

We'll demonstrate how a next generation wiki platform allows to do just that by using the XWiki open source project as an example.

Every day we imagine some new apps we'd love to have: having an application to allow people to submit talks, to register new holiday requests, expense reports, simply get data from one site and combine it with data from another site and display that, etc. This is the long tail of application (see http://platform.xwiki.org/xwiki/bin/view/Main/SecondGenerationWiki).

However in most cases we just drop the idea and continue with our life because we know it would take days or weeks to be able to develop that quickly before you could reap the benefits.

What if there was a way to have these apps developed and working in just a few minutes!

Building service orchestration with any language! Be it Bash, Python, Ruby, Chef, Node.js, Ansible, Salt, and most anything in between.

What if we could stop caring about individual machines (unless you really want to) and just model deployments in the cloud like you can with Lego blocks?

In Ubuntu we're building a collection of services, things that any one can deploy. Need a load balanced WordPress deployment with MySQL and memcached? What if instead of searching the web for "the perfect WordPress deployment" we built that into the operating system? Deploy it either via CLI or a web interface. Need more resources? Click a button for more instances.

Smart DevOps have already figured out how to deploy these services in a way that scales; what if we could encapsulate that person's expertise, generalize it, and then let everyone deploy it that way? Too many people are wasting time learning how to deploy "Hadoop" and getting lost in the weeds fixing config files rather than learning the actual technology. That's the problem we're trying to solve. Find the experts, define what a reliable, scalable, robust configuration is for that service, and stick it in the operating system, all open source, peer reviewed, and tested.

And not just for the complicated things like Hadoop. In Ubuntu we're making so services can be made into lego blocks via a tool we call Juju. With over 100 "blocks" ready to deploy, I'm going to show you how you can spend less time searching for custom AMIs all over the internet to deploying entire stacks in as little as 4 or 5 commands.

This talk is generally for system administrators and web developers (Ruby, Python, node, and so on) who want to save time when they need to spin up deployments for dev, testing, or production in the cloud, be it Amazon Web Services, HP Cloud, any OpenStack cloud, or even your own bare metal in your datacenter.

Flexible database clusters impose challenges in terms of load balancing, load splitting, write conflict avoidance, and service availability to name a few. MaxScale is a highly modular proxy with a pluggable API, which assists in offloading tasks away from both clients and the back-end servers. In its simplest form it acts as a non-blocking zero-copy load balancer for read-only connections, while in the other extreme it examines packets and parses queries, which are then processed according to the dynamically changeable rules exposed by plugged-in modules.

At its core MaxScale is a server handling massively parallel client load and processing it according to the associated router. Connections are handled with epoll, and whenever possible, packets are routed without making unnecessary copies of them. MaxScale has efficient, flexible and rich logging facilities including logging on disk, to shared memory or to syslog. MaxScale is opensource software, licensed under the GPLv2, providing a plug-in API for query routing, server monitoring and for protocols such as MySQL and httpd. Pluggable authentication is in plans. Initially supported platforms are CentOS and Debian on x86_64. In our presentation we introduce the architecture of MaxScale, modularity, the plug-in API, how it is integrated with Galera and MySQL replication, and some typical use cases.

Digital signatures for OpenOffice releases.

In this lightning talk, I'll give a quick introduction to and an overview of key concepts of Meteor, followed by live examples on how to go about creating and deploying your very own purely JavaScript-based reactive and real-time web apps.

Making reactive and real-time web applications is in fashion these days. Among popular real-time programming frameworks is meteor.js. Meteor is an open-source platform for building top-quality web apps in a fraction of the time. Meteor is based on the popular server-side JavaScript framework node.js, and relies on the easy, fast and scalable MongoDB for data storage.

Meteor gives developers the opportunity to create quality web apps completely in JavaScript. For existing web developers, this is nothing short of pure awesomeness. For others, creating new apps is simple because of the easy-to-learn language that is JavaScript. Meteor comes with a rich set of API and utilities that help in creating, bundling and deploying apps in a few keystrokes.

Meteor is maintained by an active lot of developers and contributors. As its official site mentions, "Meteor is still a work in progress", but that hasn't stopped it from attracting a lively community around it. The idea of using the meteor.js framework for building that app came from my mentor who had then recently given a presentation on it at an event. Awed by the concept of reactivity, a rich API and the power of MongoDB, I fell in love with Meteor pretty quickly.

In this session, I will quickly delve into: * introduction * key concepts * creating your first app * making your app reactive * deploying your app (taking it live)

Wrap Up

This introductory talk will set the context for the day. It will take a look at how energy efficiency is the major challenge for systems developers, and will then provide an overview of a number of open source projects that demonstrate how the energy efficiency of the entire system can be significantly improved.

Energy efficiency of systems - hardware and software - matters. For the smallest energy scavenging systems it is a matter of eking out the picowatts. For handheld consumer electronics it is battery life that is a key product differentiator. Even for mains powered consumer devices, energy efficiency affects utility bills. And for datacenters run by the Googles and Facebooks of this world, more efficient systems mean fewer new power stations need to be built.

This dev room is dedicated to the whole subject of energy efficiency in computer systems. This introductory talk provides an overview of all the approaches being taken to address this issue, particularly looking at how free and open source hardware and software is taking a leading role. It will provide a guide to the remaining sessions of the day, including the hands-on workshop where participants will have the opportunity to work with energy measurement hardware for themselves.

A quick overview of the state of Open Source Automotive software.

There are a number of initiatives around Open Source automotive software. In this short introduction we will take a look at them and the projects which are part of them. The Automotive devroom will also dig deeper into a number of areas: In-vehicle Infotainment, autonomous driving, automotive networks, and graphical interfaces in both "native" and HTML 5.

Open source software developers, just like any other developers, have to be aware of the legal liability they can incur.

The topic of this talk is the infringement liability of contributors in open source projects. Typical for open source projects is that they contain multiple (more or less anonymous) contributions by multiple developers. Since the regulation on patent and copyright protection applies also in case of open source software development, co-authors in the project should take care that the re-use of pieces of code does not infringe intellectual property rights of third parties.

The proposed talk aims to address two pertinent questions in this regard: - Can co-authors, contributing to an open source project, be held liable for the wrongful re-use of code by other co-authors, contributing to the project? - If so, which legal mechanisms could be used to protect good faith OSS developers against such liability?

This research is funded by the EU FP7 Framework Programme under grant agreement No. 318508 (MUSES).

This talk will present a quick summary of the current state of Wine and of the plans for the upcoming 1.8 release.

VirtualSquare community has created a number of tools for virtuality: VDE, View-OS, PureLibC, LWIPv6, etc. An entire new generation of our tools is being designed. This seminar will provide a preview on new developments and new features.

News ideas and tools will be presented during this seminar: - modular libvdeplug - vde-vxlan - parallel ptracing - ... and many others (all those which will be demo-able in time for the Fosdem date)

The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines, though it does provide helpful libraries that can be used to build them. The name "LLVM" itself is not an acronym; it is the full name of the project.

LLVM began as a research project at the University of Illinois, with the goal of providing a modern, SSA-based compilation strategy capable of supporting both static and dynamic compilation of arbitrary programming languages. Since then, LLVM has grown to be an umbrella project consisting of a number of subprojects, many of which are being used in production by a wide variety of commercial and open source projects as well as being widely used in academic research. Code in the LLVM project is licensed under the "UIUC" BSD-Style license.

The LLVM dev-room gives room for open source projects to get to know LLVM and to present to a wider audience how they use LLVM themselves.

A short introduction of the hosts of the devroom and some warm words.

So far, the Python community has shown little interest in Logic Programming.

Yet, it is one of the three main programming paradigms, together with imperative and functional programming. Thanks to pyDatalog, a Python package which embeds Logic Programming within Python, Python programmers can now solve complex problems through highly readable and declarative programs. This talk will introduce you to Logic Programming through examples written in Python + pyDatalog.

The LLVM clang C++ compiler has exceeded all expectations the last year, gaining unprecedented new features that let you explore, rewrite, and rediscover your source code.

This is a talk about the human story of a compiler: What can we achieve going beyond compilation? Why are we compelled to invent a better wheel? How can we make everyday life better for coders, and could the compiler itself become an instrument for wider social change?

Developed by an eclectic team of academics, supercomputer hobbyists and vendors including Apple and Google, the LLVM project has proven itself as a hotbed of innovation leading the renaissance in C-family programming languages, recently receiving the coveted ACM Software System Award.

Whether you’re a kernel hacker, app developer or front-end designer, clang is different to other compilers, it’s coming to a machine near you in 2014 and may well impact your work: Here’s what you need to know.

The talk will concentrate more on anecdotes from the "drivers first" development approach. Technical details for how rump kernels work will be provided as links.

Rump kernels are NetBSD kernel drivers running on top of a set of high-level hypercalls. The term "drivers" is used in the broad sense, and includes for example file system, TCP/IP and system call drivers. The hypercall interface makes virtually no assumptions about the host, apart from it being able to execute code and access I/O functions required by the drivers (e.g. NIC-like devices for the networking stack). The original motivation for rump kernels was being able to debug NetBSD kernel drivers in a nice, non-monolithic kernel environment (i.e. userspace processes). This motivation dictated that drivers running in the non-monolithic environment had to be unmodified with respect to the NetBSD kernel version under the hammer. The implication was that instead of modifying drivers to work in userspace, NetBSD was modified to allow the drivers to run anywhere. The result of work begun in 2007 is that NetBSD kernel drivers from any snapshot or release of NetBSD now run more or less anywhere: in userspace on most operating systems, in a web browser, on top of the Xen hypervisor, or in the Linux kernel. The only component required for running NetBSD kernel drivers in a given environment is the rump kernel hypercall implementation. This implementation generally speaking 1000 lines of code (figure includes comments and whitespace and rudimentary I/O access routines).

This talk will discuss the basics, the challenges, and the possibilities of graph construction.

Often, the most painful and time-consuming part of graph processing at the massive scale is constructing the graph from raw data.

Technologies such as the many Hadoop/Python make it possible to create ad-hoc solutions. But even then, the task requires familiarity with writing and debugging Map-Reduce code, and graph construction can involve consistency checks and cleanup tasks that can prove tricky even for experienced data scientists.

The Intel Graph Analytics operation has been using the GraphBuilder library of tools in multiple projects analyzing large scale graph data, and recently an alpha version of the toolkit has had an open source release in Pig. GraphBuilder occupies the boundary between non-graph and graph processing: Raw data comes in from text files, big tables, etc, non-graph transformations are performed in Pig, then rules are specified to construct the graph from raw data, and finally the graph is stored in a graph database, such as Titan, or in a standard graph format, such as RDF.

Where'd you get that big old graph?

Having all your media available in the car is the Holy Grail for carmakers. Unifying playlists, quick access to Internet radio, AM/FM, and traffic information is a complex task. This talk will discuss the currently available ways to index media in the car providing one of the pieces of the complex puzzle.

Indexing media can be CPU and memory intensive, so what are the best strategies? What tools can be reused to get from to here to there more quickly? What is the vision of car makers, what are they looking for. We'll try and address those questions and provide some room for discussion on the best path forward.

In this talk, I will introduce the need for energy measurements for embedded devices and show how they may be performed accurately and for very low cost using a combination of off-the shelf parts and a wide range of target embedded systems.

I will cover the basic physics of energy measurement and go on to display designs for energy measurement kits, including the power sensing boards recently developed as part of the MAGEEC research project.

This talk will discuss how Pipelight combines Wine with native Linux code to run Windows NPAPI plugins such as Silverlight, Flash, and Unity3D in Linux browsers.

Pipelight is a special browser plugin which allows one to use Windows browser plugins inside Linux browsers. To make this possible Pipelight acts as a normal plugin and redirects function calls through a pipe to a process running in Wine. Although the idea may seem to be a bit overly complicated at first sight it turned out to be very useful from many perspectives. This approach allows for the seamless integration of these plugin into Linux browsers, while only running the plugin itself in Wine (which improves the performance and makes debugging a lot easier). In this talk we will especially focus on what is going on behind the scenes. We will show various problems we came across while developing Pipelight when trying to combine Linux and Wine applications inside a single project and explain how it is possible to translate between the differences of the Linux and Windows API and NPAPI. We will also talk about changes we made to Wine, including embedding the Wine window inside the browser and properly capturing input for the embedded windows. While working on Pipelight we also stumbled over bugs and raceconditions inside browsers like Chrome or Opera and the plugins themselves. We'll briefly talk about these issues and how Pipelight tries to workaround them. Last, but not least, we will discuss the security aspects arising from running Windows plugins and how Pipelight intrinsically protects you from certain kinds of attacks without any extra configuration.

py.test is a powerful and Pythonic unit testing tool which can scale from a few quick no-boilerplate tests to running huge unit and integration test suites.

One unique and powerful feature of py.test the dependency injection of test fixtures into the tests using function arguments. While the injection of fixtures via function arguments looks uncommon when used to the traditional JUnit setup and teardown mechanisms, py.test's fixtures are simple yet very flexible and arguably more powerful. This talk will walk through simple fixtures building up to show how to create more complicated setups by composing fixtures, controlling their scope and paremetrisation. This should lead to a good understanding of why fixtures are designed the way they are and why this is a very good and helpful mechanism to setup a test suite.

The organizing team will welcome you and kick off the first ever Fosdem Javascript Devroom!

Nowadays software is usually a combination of own-written code and FOSS; in some cases it also contains parts licensed under non-FOSS licenses. FOSS licenses stipulate different obligations and, in order to be legally compliant, one has to abide by the obligations of every license.

This talk will present lessons learned while building a corporate compliance system that is sensitive to the needs of developers while still pleasing the lawyers.

This talk will present lessons learned while trying to ensure legal compliance in a large company. It will touch upon different aspects of the set of processes and mechanisms used. Such mechanisms exist to provide answers to questions such as: - how can FOSS be used? - how can FOSS be integrated? and - how can FOSS be released?

It is obvious that the task of legal compliance involves developers as well as people from legal professions; therefore an important part of structuring any system or set of processes has to be the satisfaction of both these groups of users. More specifically, legal people should neither become overwhelmed by their tasks, nor end up being the bottleneck of the whole workflow. On the other hand, software development should be disrupted as little as possible, since this is usually the main business.

It is hoped that such practices can greatly help everyone facing this inherently difficult and potentially risky issue. Moreover, such practices can facilitate the use of FOSS in a commercial environment.

Embedded systems are becoming powerful enough that virtualization is now both possible and interesting. Xen, as a very tiny microkernel based hypervisor looks like a very good fit for the embedded environment, not to mention that it has been ported to ARM with the number of supported boards in constant increase.

This talk will outline the major strengths of the Xen architecture, when it comes to use Xen on embedded systems. It will also identify and discuss the areas where there is still room for improvement. It will go through preliminary experimental results on assessing some of the typical real-time requirements (such as responsiveness and predictability), for the benefit of everyone out there that would like to build its embedded product on top of Xen.

On the concrete side, we will show how to setup an 'Andorid on Xen' environment, which results from a fruitful collaboration between the Xen community and other interested parties from the Android community. We think this could be very useful as an example for anyone interested in working with us, with the aim of being successful in the embedded virtualization product space.

Full description: The goal of this talk is twofold: - provide a general enough view of the Xen architecture, focusing on

why it could be particularly well suited for the embedded
virtualization usecases

• show how the Xen community is tackling this new challenge, trying to involve all the (potentially) interesting parties and reaching the highest possible levels of cross-project collaboration

Outline: * Embedded virtualization: some typical usecases * The xen architecture, and why it fits so well there

 * it's tiny: small memory footprint, easier to certify
 * it's extensible: pluggable scheduling architecture
 * it's flexible: different Dom0s, driver domains

• Areas of further improvements:
  • new hard real-time schedulers
  • more determinism within the driver model
• Some benchmarks on how Xen behaves in low latency workloads
• Already ongoing projects/effort:
  • Xen on tablets, cars, industrial CNCs, ...
• Bootstrapping a (sub)community
  • getting in touch with all the interested parties
  • keeping in touch with them
  • handling feedback, coordinate collaboration
  • concrete example: setup a Android on Xen environment

Your host adg will kick off the Go Devroom with some opening remarks.

With the help of the audience, I'll try to create a complex webapp within 30 minutes. Complex in the sense of: Custom use case (unprepared, told by audience), custom JSON/REST backend, beautiful HTML5/CSS3 template, dynamic data, user interaction, Twitter/FB connect). Everything we need is the Open Source framework Structr, on top of the graph database Neo4j. This will be very interactive, and even fun if it works. ;-)

This year is the first year that FOSDEM will have a developer room dedicated to Software Defined Radio. Here, we will present a quick overview of SDR projects out there and those attending FOSDEM and then start off the day.

Welcome to participants and explanation of the devroom format.

The Genode OS project started 2006 as tool kit for building microkernel-based special-purpose operating systems. Over the course of the past years, it has grown to a state where it becomes feasible to be used as general-purpose OS for daily computing needs. This talk will present the many challenges that we faced on our way during the past year.

The topics range from making microkernels such as NOVA fit for highly dynamic workloads, over the creation of low-level OS infrastructure and the porting of existing software stacks, to the question of how the user interacts with a system that that largely deviates from the classical path of Unix-like OSes. In the line of the presentations of the past years, the talk will be garnished with various demonstrations.

OpenStack is a large infrastructure software stack openly developed by hundreds of developers across the world, producing hundreds of changes per day. How do we stay sane, make sure this complex software stack works, and produce releases every 6 months like clockwork?

In this talk, we'll look into the principles behind the OpenStack gate, which ensures that every proposed change goes through rigorous automated testing before being merged. We'll look into the implementation details of our cloud-based solution, which involves Jenkins, Gerrit and a set of homegrown open source tools. We'll explore the unique set of challenges created by running such a strict gating system while maintaining our development velocity. And best of all, we'll see how this whole system setup is entirely automated by Puppet with open-sourced configuration everyone can contribute to.

This talk should appeal to anyone interested in successfully applying testing and automation principles in large open source projects. No previous knowledge of OpenStack is necessary.

Presenting how to easily use Excel as a container for typed tabular data in Python, performance hints, and a progress status of the library after 3 years of development.

F-Droid brings Free Software to your Android and helps you regain control over your device.

A project founded in 2010, its aim has always been to deliver Free Software to our users similar to how most repository-based GNU/Linux distributions do it. We believe that this makes the project a crucial part in Android as an entirely free system.

Over the years, the project has grown and matured. The quantity and variety of apps available in the main repo have increased, but it has been after the many privacy scandals in 2013 that people and the media have started paying more attention to the project.

In this talk, we will try to show how useful can F-Droid be to not only app developers and maintainers, but also to everyday users who would like to know what is being installed on their devices.

This talk introduces OpTiMSoC, a set of open source building blocks to create your own System-on-Chip, which then runs on an FPGA or can be simulated on a PC. The system is formed by tiles like processors or memories connected by a Network-on-Chip, all written in Verilog and supported by a set of software required to run it out of the box. The talk shows how you can use OpTiMSoC to gain insight into a complex System-on-Chip, to evaluate the benefit of new hardware accelerators, or to compare different multicore hardware architectures.

Have you ever wondered what exactly is happening inside a System-on-Chip, like the one that's inside your cellphone, your washing machine, or your car? Have you ever thought "wow, this algorithm could be implemented so much faster in hardware"? Do you do research on embedded hardware architectures and need a platform on which you can try out your ideas?

Then we might have something for you: OpTiMSoC. The "Open Tiled Manycore System-on-Chip" is an open source collection of building blocks to create your own System-on-Chip (SoC). It is based on the concept of "tiles", elements like CPUs, memories, hardware accelerators or external interfaces, which are connected by a Network-on-Chip. On top of those hardware components, which are written mostly in Verilog and can be synthesized to run on an FPGA as well as simulated on a PC, OpTiMSoC contains all necessary software components to get a SoC up and running (a basic "operating system", a C library port, debug support). Of course some running demo systems are included, so you can get started easily by modifying existing designs.

OpTiMSoC was designed by researchers at the Technische Universität München (TUM) and is used there to evaluate new hardware architectures. Over the last two years it grew massiveley in scale and we think it's now useful to others as well. By providing a signal-level insight into a complex SoC it serves as teaching tool and as experimentation and research platform at the same time.

This talk gives an overview over OpTiMSoC, how we use it and how you can make use of it to realize your own ideas.

python-netsnmpagent is a Python module that facilitates writing Net-SNMP subagents in Python. Subagents connect to a locally running Master agent (snmpd) over a Unix domain socket (eg. "/var/run/agentx/master") and using the AgentX protocol (RFC2747). They implement custom Management Information Base (MIB) modules that extend the local node's MIB tree. Usually, this requires writing a MIB as well, ie. a text file that specifies the structure, names and data types of the information within the MIB module.

This lightning talk will give a really quick introduction to SNMP and MIBs and show how easy it is to implement your own custom MIBs using Python and python-netsnmpagent.

The mbed platform is a framework for developing embedded applications with ARM MCUs. It consists of a SDK (software development kit) and a HDK (hardware development kit) which work together to provide a complete software and hardware solution and reference platform for developing a broad range of embedded applications.

mbed also provides a platform agnostic on-line development environment that can be used to develop embedded applications, as well as a large number of drivers and libraries for various peripherals and protocols, many of them written and maintained by a large community of open source developers. Applications can also be exported (and subsequently developed) off-line for a number of popular IDEs. The whole framework is provided under a permissive open source license that allows using the framework for both non-commercial and commercial applications. This presentations will give an overview of the mbed framework, with an accent on how easy it is to develop embedded applications with mbed.

Three years ago, the Intel kernel gfx driver infamously occupied the top spot on the regression list. This sordid state has massively improved thanks to a big effort over the past few years.

This talk will detail what we've all done to achieve this. Process improvements, improvements in the driver, test-suite infrastructure and new testing techniques developed to exercise specific features will all be covered. And of course a unsparing look at what didn't work out, what still needs to be improved, and the plans for the near future won't be missing, either.

AppStream provides a solution for application-centric software management using existing package managers, while Listaller extends the package manager with the ability to install 3rd-party applications in a secure way, without introducing additional UI. This talk explains the basic concepts of both projects and the motivation behind them, as well as the obstacles in cross-distro collaboration which we hit while developing these tools.

Software management on Linux is traditionally done using packages, although desktop users are more interested in applications instead and do not care much about how something is packaged. Also, users often want to install software which is not available in the repositories (e.g. unpackaged stuff, as well as new versions of applications), without having to upgrade the whole distribution. AppStream provides a solution for application-centric software management using the existing package-managers, by providing extra metadata for packages. This allows developers to create cross-distro application-centers, like GNOME-Software or Apper. Listaller extends the package manager with the ability to install 3rd-party applications, which are not (yet) in the distribution's repositories. It builds on top of the AppStream specs and focuses on integration, so the installation process is completely transparent for users, and Listaller-installed applications can be managed with existing software-management tools. Because software from 3rd-party sources is a potential security risk, Listaller also tries to give users a hint if they can trust a certain application, and includes sandboxing for these applications. Both projects rely heavily on metadata provided by upstream projects and distributions. This talk will explain the concepts of AppStream and Listaller, which new metadata needs to be added and why as well as how distributions can make a software-center available for their users. If the time allows it, the talk will also highlight the problems we had with the AppStream project in the first place and how we could improve cross-distribution collaboration in general.

The next larger step in automotive development will be towards autonomously driving cars. Autonomous driving is a highly complex and safety-related function in future vehicles, and current software platforms are not adequate for this function. We present our ongoing research on an open-source software platform for autonomous driving software systems.

From our experience with use cases of existing driver assistance systems and research projects, we derive requirements on the software platform. We show the advantages of open-source development over proprietary development and provide arguments for an open-source qualified (open-proof) software platform. Furthermore, we propose an architecture for the software platform based on the Linux operating system and other open-source software. This architecture fulfills the requirements and makes development and qualification of such systems efficient.

As developers of open source and free software, we share our code freely, we make a positive change on this world. However, too often great pieces of open source software are declined for integration inside amazing projects. Aren't they good enough? From a technical perspective, yes. But when you don't express clearly which licenses and third-party resources were used (images, libraries, code) then these "unknown libraries" become too much a risk to bear.

Are we doing the right things in regards to licensing? Come and join our talk to find out.

We'd like to change that, ensure that licensing terms are not a burden to explain. Some developers use a web page, others Maven and mature projects include source code headers. Yet, we need a consistency, we need a way to check and revise if the licensing attributions are correct or not. The SPDX document from the Linux Foundation helps to make this possible. Anyone with a text editor can double-check which licensing terms are applicable, where the third party resources come from and solve the exposed issues.

The Linux Foundation promotes a document format for exchanging open source licensing information. It is called SPDX. The basic principle is that you should be able of describing the applicable license terms for your software, for the libraries that you are using and give the licensing details that are needed for sharing your work. In return, people receiving your software can either read for themselves what licenses are applicable or use tools that help get this sorted across thousands of files.

It is not a complicated document to understand, it is a plain text file. On our talk we discuss the specific cases where SPDX documents make a difference to bring transparency and the techniques/tools that are used for creating them. We cover cases of mixing multiple libraries and what you should take into attention when placing these libraries inside your own software.

This is an intense lecture, bring a camera to take quick pics of the slides that you find interesting and a laptop to test your licensing investigation skills right there in the class room.

Heterogeneous systems as found in the Internet of Things are made up of many devices of different types working together. Each device class is typically developed with separate tools using different paradigms. We propose that using NoFlo and MicroFlo one can develop heterogeneous systems consisting of micro-controllers, servers, and mobile devices using flow-based programming (FBP) as an unifying programming model.

Systems qualifying for the label "Internet of Things" are often complex hetrogenous systems consisting of many nodes spanning over several device classes, working individually and together to realize the intended function: Microcontrollers w/peripherals are used as sensors and actuators, servers used for data-aggregation and analysis, desktops and mobile devices as user interfaces for monitoring and configuration. Typically each of these classes of device are programmed with separate tools, by different people using different paradigms: for example C/C++ for microcontrollers, Python for servers, JavaScript+HTML5 for user interfaces.

This talks aim to introduce flow-based programming (FBP) as a programming paradigm that can be used across and between device classes, and to show how NoFlo and MicroFlo can be used to implement heterogeneous systems.

About: NoFlo is a JavaScript-based FBP runtime by Henri Bergius, which runs on Node.js and in the browser. http://noflojs.org MicroFlo is a C++ based FBP runtime by Jon Nordby. It runs on AVR and Cortex-M microcontrollers, including Arduino. http://microflo.org

NoFlo and MicroFlo can both be targeted by the NoFlo UI, an IDE for flow-based programming currently in development. Systems can be programmed visually, using a domain-specific language or the runtimes can be embedded and controlled programmatically.

Although GNU Radio is now over ten years old, the project has recently seen an incredible amount of growth in features. The capabilities we have been adding to the project are focused on improving current signal handling techniques, extending the GNU Radio project's ability to handle newer and developing digital wireless signals, and focusing more on the embedded systems world.

In this talk, we will go over the basics of GNU Radio and a list of some of the newer features. We will then explore a few ways of interacting with GNU Radio to explore the wireless spectrum and signal processing techniques. To do this, we will look at how we use concepts of GUI instruments and interactions, stream tags and messages, and ControlPort for monitoring and controlling GNU Radio applications.

Elasticsearch has reached 1.0 with many new exciting features including backup & restore, aggregations, and many other smaller changes. I'd like to introduce what's new on real life examples and show what they can be used for.

Elasticsearch is an open-source fully distributed search engine based on Apache Lucene. In the month prior to Fosdem there should be a 1.0 release that introduces a lot of exciting features as well as other properties - backwards compatibility guarantee for example.

The talk will start with a brief introduction of what Elasticsearch is and what it can be used for. After a brief run through of the existing features we will dive into the new features, each one will be introduced and then shown in real-life code examples and live demo.

There are thousands of examples, using a myriad of JavaScript frameworks, of how to code a To-Do list. However, when looking for examples of more complex architectures, it is easy to despair.... Based on experience gathered as a Web Developer at trivago, here is one approach to structuring complex JavaScript applications using AMD, modules, and Backbone.

For developers, it can often be a bit of a learning curve to learn the proper use of a new tool. For certain development tools the entry barrier can be quite high and can often discourage users. The Linux Tools Project aims to improve the state of C/C++ development on the Eclipse IDE by integrating popular tools, such as Valgrind.

This talk is aimed at people of varying experience with the Valgrind tool who have never used it within the Eclipse IDE.

An overview of the Eclipse Valgrind plugin provided by the Linux Tools Project will be given. Topics discussed will include :

• Quick overview of the Linux Tools Project
• Introduction to the Eclipse Valgrind plugin

Demonstration - Memcheck, Massif, Helgrind, Cachegrind support - Eclipse Platform specific integrations (Error markers, Problems View) - Simple Auto-correction for common Memcheck/Helgrind problems - Support for execution on remote targets

• Possible improvements to Valgrind tool

• Challenges faced regarding Valgrind tool

Auto-Vectorization has come a long way since the early vector-processing CPUs, and compilers generally take a long time to implement it, prioritizing other more generic features instead. But with all recent high-end chips containing some form of SIMD operations, auto-vectorization became a necessary feature on any modern compiler. LLVM was perhaps the last of the big compilers to have a decent vectorization engine, but it has grown considerably for the last year, and the investment on SIMD code generation will not diminish. This presentation outlines the past implementations, what we currently have available and peeks into the engineering pipeline to see what else we are working on.

To cope with an ever increasing number of internet connected devices, large scale computer clusters are becoming an everyday requirement for any web-service provider; and with the prevalence of compute clouds, these can be obtained effortlessly at a scale that was previously unimaginable. However, the distribution models available have not caught up with the advancements of clouds yet, and as such, distributed programs running on top of these platforms require significant efforts to take full advantage of their hosts' capabilities.

We introduce a unique concept into the domain of distributed computing, namely, that the idea of a specific node is impedimental to scalability. The proposed model to achieve a robust system is to raise the unit of abstraction from a single node to a cluster of nodes sharing the same responsibility; and to eliminate all notions related to location, further breaking dependencies between distributed entities.

Iris is a decentralized messaging framework with the specific goal of simplifying the development and maintenance of cloud based back-end services by striving towards zero configuration through complete self-organization; achieving full messaging security out of the box; whilst providing the communication primitives to support easily assemblable distributed systems.

Energy models can be constructed by characterizing the energy consumed by executing each instruction in a processor's instruction set. This can be used to determine how much energy is required to execute a sequence of assembly instructions.

However, statically analyzing low level program structures is hard, and the gap between the high-level program structure and the low-level energy models needs to be bridged. We have developed a tool for performing a static analysis on the intermediate compiler representations of a program. Specifically, we target LLVM IR, a representation used by most modern compilers including Clang.

One of the challenges in doing so is that of determining an energy cost of executing LLVM IR program segments, for which we have developed a mapping tool. This tool associates LLVM IR program segments with assembly program segments, producing a mapping. Mapping information is useful when performing an analysis at one layer using energy models defined at a lower layer. Essentially, this propagates the energy model defined at the instruction set level up to the LLVM IR level, at which the analysis is performed. When this is used with our analysis tool, we are able to infer energy formulae that characterize the energy consumption for a particular program. This approach can be applied to any languages targeting the LLVM toolchain or architectures supported by LLVM.

Static energy estimation has applications in program optimization, and enables energy-aware software development.

GraphHopper is a fast Open Source road routing engine written in Java running on the server as well as on Android. It uses OpenStreetMap as data source and implements road routing via Dijkstra algorithm and variations. In this talk I'll describe the challenges faced while implementing fast and memory efficient graph algorithms and storage solutions.

GraphHopper is a fast Open Source road routing engine written in Java. It uses OpenStreetMap as data source and implements road routing via Dijkstra algorithm and variations. To make shortest-path calculations in under 50ms possible - even for paths of continental length - GraphHopper uses a special "shortcut-technique".

In this talk I'll give you a brief summary of the internal graph representation and how to scale this to gigabytes of memory and still make it running on Android. Including a short overview of Dijkstra, the memory efficient graph traversal API and how to map the real, geographical world with GPS coordinates and roads into a mathematical graph representation with edges and nodes.

This talk will cover * a short intro to ovirt * a bit about the code contribution effort by eldorado.org research center that made this happen * design consideration of multi arch support - objectives and constraints * basic flow for provisioning PPC enabled clusters * some code, config files etc to demonstrate what ties it up altogether

Target audience: Whoever is interested in data-center virtualization in general, ovirt-engine specifically, and PPC support.

Getting cross-platform: bringing virtualization management to the PPC world oVirt, the open source data center virtualization management solution is expanding the x86_64 architecture support to PowerPC hardware, among them IBM Power processor based hosts.

Entering PPC world raises challenges of managing mixed arch data-centers with the need to distinguish PPC from x86_64 VMs. In this session we'll cover the main differences in virtualization needs, how we enabled the support for that in our management engine(a.k.a ovirt-engine)

PPC virtualization main differences is in virtualized devices supports. Built around x8664, ovirt-engine needed to expand its cluster and VMs provisioning to fit multi architecture, and to keep migration support and proper VM configuration solid for the supported operating systems. Since some parts are work in progress (e.g live migration) for the PPC VDSM, the engine has to also manage features which are not supported for PPC while is supported for x8664

To cope with a change that span various parts and components a repository for Operating Systems and they're hipervisor's demands was created along with strategy functions around the code to ensure correct provisions and life cycle related VM functions.

The session will cover what is now supported (hypervisor and VM OSs), how we provision PPC clusters and VMs and a little deeper dive to explore the mechanisms which enabled this multi-platform support along with some code examples (yes, we're going to see some code!)

Cfg2html is a little utility to collect the necessary system configuration files and system set-up to an ASCII file and HTML file. Simple to use and very helpful in disaster recovery situations.

Collects Linux system configuration into a HTML and text file. Config to HTML is the "swiss army knife" for the sysadmins. It was written to get the necessary informations to plan an update, to perform basic trouble shooting or performance analysis. As a bonus cfg2html creates a nice HTML and plain ASCII documentation from Linux System, Cron and At, installed Hardware, installed Software, Filesystems, Dump- and Swap-configuration, LVM, Network Settings, Kernel, System enhancements and Applications, Subsystems.

Valgrind is a tool which can be used for testing but also needs to be tested itself as any other piece of software. This talk will focus on testing done before releasing a new Valgrind RPM in Red Hat Enterprise Linux.

Overview: - types of tests I do - what they are trying to achieve - what bugs I often hit - ideas I have for improvement - Q/A + Discussion (perhaps how to work closely with upstream)

You have data stored somewhere and you want to expose it to your users through a RESTful Web API. How?

Eve is the BSD-licensed, Flask-powered tool that allows you to quickly and easily go online. Eve provides a robust, feature rich, REST-centered API implementation. MongoDB support comes out of the box, and community-driven efforts to deliver ElasticSearch and SQLAlchemy data layers are ongoing. Eve approach is such that you only need to configure your API settings and behaviour, plug in your datasource, and you’re good to go. Features such as Pagination, Sorting, Conditional Requests, Concurrency Control, Validation, HATEOAS, JSON and XML rendering, Projections, Customisable Endpoints are included. Advanced features such as custom Authentication and Authorisation, Custom Validation, Embedded Resource Serialisation are also available. In my talk I will introduce the project and its community, recount why and how it's being developed, and show the current roadmap.

Report and discussion of issues that impact Wine users.

The aim of this talk is to introduce OpenIoT, a FOSS project for developing/integrating Internet-of-Things (IoT) applications and services. OpenIoT is developing a platform and a range of tools for developing and deploying non-trivial IoT solutions. The introduction of the project will be made in the form of a lecture/presentation/lighening talk, yet it will also include practical examples and demonstrations of IoT applications based on the OpenIoT platform. Furthermore, a short programming tutorial could be provided. The aim of the presentation will be to attract interested developers/contributors to the project, thereby boosting OpenIoT's community building efforts.

The main goal of the OpenIoT project (openiot.eu) is to develop a bluepring middleware infrastructure for implementing/integrating Internet-of-Things solutions. OpenIoT is supported (co-funded) by the European Commission as part of the FP7 programme. It is a joint effort of several developer teams around Europe, including open source enthousiasts and developers of other prominent open source IoT platforms such as Global Sensor Networks (GSN) (http://sourceforge.net/apps/trac/gsn) and AspireRfid (http://wiki.aspire.ow2.org).

OpenIoT is a java-based IoT project, which features unique properties. In particular, it provides the means for:

1.Collecting and processing data from virtually any sensor/ data stream, including physical devices, sensor processing algorithms, social media processing algorithms and more. In OpenIoT the term sensor refers to any components that can provide observations. OpenIoT will facilitate the integration of the above sensors with only minimal effort (i.e. few man days effort) for implementing an appropriate access driver. 2. Semantically annotating sensor data, according to the W3C Semantic Sensor Networks (SSN) specifications (http://www.w3.org/2005/Incubator/ssn/). 3. Streaming data of the various sensors to a cloud computing infrastructure. 4. Dynamically discovering/querying sensors and their data. 5 Composing and delivering IoT services that comprise data from multiple sensors based on minimal programming and through the use of visual tools. 6. Visualizing IoT data based on appropriate mashups (charts, graphs, maps etc.) 7. Optimizing resources within the T middleware and cloud computing infrastructure.

The above features make the project innovative and differentiate it from other/similar IoT middleware projects.

The OpenIoT founders and developers aspire to gradually engage open source developers in the OpenIoT community, as users, developers and contributors. The development and expansion of an open source community is deemed as a critical step for improving the project and boosting its wide adoption.

The project's presentation during FOSDEM could comprise: 1. An overview presentation of the project. 2. An anatomy of the open source components comprising the FOSS project on Github. 3. Short/targeted demonstrations of IoT applications build based on the project. 4. Short tutorials on downloading/using/deploying OpenIoT 5. Q&A sessions aiming at resolving key questions and issues.

Meet the mbed open platform for developing ARM-based embedded devices. A clean and concise presentation about how to start developing today your new embedded device on the mbed platform only using the Free GNU GCC Toolchain and the open mbed SDK (Apache v2).

mbed is an open platform for developing ARM-based embedded systems (with a focus on IoT devices).

The aim is to build a platform and ecosystem of open-source software and hardware building blocks that are available to a very wide professional developer audience, allowing new industries to take advantage of the huge potential IoT presents. Think embedded intelligence everywhere...

This talk will provide an overview of the platform and a clean and concise presentation about how to start developing today your new embedded device on the mbed platform only using the Free GNU GCC Toolchain and the open mbed SDK (Apache v2).

• mbed SDK: https://github.com/mbedmicro/mbed
• GNU Tools for ARM Embedded Processors: https://launchpad.net/gcc-arm-embedded

Avatar is a research framework that enables complex dynamic analysis of embedded devices by orchestrating the execution of an emulator together with real hardware. It is built on top of S2E/Qemu, KLEE and LLVM and its main goal is to enable advanced security analysis of pristine ARM source-less firmware, eg. through dynamic tracing or symbolic execution.

This talk will show key features of S2E in enabling runtime binary analysis (using Qemu virtualization and KLEE/LLVM symbolic execution) and how Avatar uses it to orchestrate analysis and execution at the emulator<->device edge.

To address the growing concerns about the security of embedded systems, it is important to perform accurate analysis of firmware binaries, even when the source code or the hardware documentation are not available. Unlike static analysis, dynamic analysis relies on the ability to execute software in a controlled environment, which is however difficult due the lack of documentation and the large variety of subtly different hardware on the market.

In this talk we present Avatar, a framework that enables such complex analysis of embedded devices. In particular we will introduce S2E, a C++ project which leverages several components to do binary emulation, including: * Qemu for machine virtualization * LLVM as the IR of choice * KLEE for symbolic execution of LLVM IR * S2E plugins for hooking into data and control flow

Then we show the Avatar framework, which acts as an analysis driver, context switcher and memory forwarder. Avatar is currently written in Python and on top of basic features, it includes several techniques to improve the system's performance as well as heuristics to help in vulnerability discovery.

Both project are FLOSS. S2E is a research project from EPFL, while Avatar is under development at Eurecom.

Camlistore (camlistore.org) is your personal storage system for life, putting you in control, and designed to last. It's open source, under nearly 4 years of active development, and extremely flexible. Come see why we built it, what it does, and hear about its design.

Camlistore is your personal storage system for life, putting you in control, and designed to last for generations. See camlistore.org.

It's open source, under nearly 4 years of active development, and extremely flexible. Come see why we built it, what it does, and hear about its design.

We'll discuss philosophy (data ownership, decentralization, data archaeology), pragmatism (dealing with real users), show plenty of demos, and show the design of Camlistore, including its abstractions which let us run on any device, desktop, cloud, or platform: ARM plug devices, Android phones, desktops, servers, EC2, App Engine, etc. Storage can be any mix of local disk, S3, App Engine, MySQL, Postgres, SQLite, Level-DB, Mongo, WeedFS, etc.

While language-agnostic with multiple implementations, Camlistore's primary server and set of tools are written in Go. We'll try to be only moderately religious about how much we love Go, what we get from Go, and how much of Go's standard library evolved first within Camlistore.

In addition to discussing what we've built so far, we'll discuss the future and how we'd like to see web services work with regard to data ownership and what we're doing to push things in that direction, both technically and politically (standards bodies, etc).

About the presenters:

Brad Fitzpatrick leads the Camlistore project and currently works on the Go language, having previously made LiveJournal, memcached, OpenID, gearman, MogileFS, and other tools. He also continues to help push WebFinger. Mathieu Lonjaret works full time on Camlistore. Andrew Gerrand also works on the Go language and contributes to Camlistore.

The public libraries in Denmark wanted an admin system for their new BibOS-system, which is an Ubuntu-based GNU/Linux distribution for audience PCs. To achieve this, we built a completely new and completely free administration system for Debian-based PCs.

The public libraries in several Danish municipalities are in the process of switching their audience PCs from Windows to Ubuntu.

They needed a central administration system to manage it, and Canonical's Landscape product was unacceptable for them; they needed the system to be completely free/open source, and Canonical's licensing when running Landscape as software-as-a-service was too expensive. The available free alternatives are either too technical for library staff, or they don't support Debian-based systems well.

In response, we created "BibOS Admin", a completely new administration system for all Debian-like systems. It enables users to remotely manage, maintain and upgrade PCs and run arbitrary, centrally defined scripts on them. The system is designed to be easy to use for non-technical staff who can rely on a set of pre-defined scripts, which should be set up as part of the setup for each organization (source code available here: https://github.com/magenta-aps/bibos_admin).

In the talk, I will discuss the technical and organizational challenges of building a new management from scratch in collaboration with the public libraries in Aarhus and Silkeborg, who kindly funded the effort.

Most of the flexibility that has been brought to the development of software defined radios resides in components that can be associated with the physical layer of the radio. This talk tries to shed some light on how SDRs can also benefit from flexibility in higher protocol layers such as link-layer protocols.

Specifically, the talk introduces a component-based link-layer protocol architecture that allows to build self-contained protocol components that can be combined to complete link-layer protocol solutions in a Lego-like manner. The talk will cover some architectural aspects as well as some implementation-specific problems that we came across during the development of a prototype using Iris.

The Linked Data Benchmark Council (LDBC) is an initiative to develop industry-grade database benchmarks. This talk focuses on the activities of its Social Network Benchmark (SNB) task force of LDBC, which developed an advanced graph generator during past year which creates a huge social graph with realistic correlations between structure and data. The datasets it generates will be tested by three different workloads (interactive, BI, graph anatytics), that I will shortly outline.

talk will cover: - mission of LDBC in general and the social network benchmark task force in specific - the LDBC social network graph generator; * schema, data examples * how it generates correlated data * technical information - benchmarks that use it: * interactive workload: many small graph queries and updates * business intelligence workloads: grouping, counting, subqueries and graph navigation * graph analytics: algorithms (not queries) that analyze graphs (e.g. clustering, pagerank, etc)

In this presentation, I will briefly talk about the developments that have taken place within the HelenOS project since the last FOSDEM. Codewise, I will mention both the new interesting features already merged into the HelenOS mainline repository and a selection of not yet merged ones. This includes features from a variety of areas such as networking, file systems, platforms, audio, testing, and others. In addition, I would like to utter a word or two about our participation in the Summer of Code in Space program during 2013.

Franca is an open source framework for definition and transformation of software interfaces. It is especially useful for integrating software components e.g. in the context of the GENIVI Automotive/Infotainment platform.

In this presentation, we will show how Franca helps in building HTML5 user interfaces. From Franca interface definitions, code is generated which connects the JavaScript client to the underlying server application via Websockets. Franca has been proposed as an official Eclipse project (http://www.eclipse.org/proposals/modeling.franca).

Developing large apps is difficult. Ensuring that the code is consistent, well structured, tested, and that the architecture encourages maintainability is essential. When it comes to building large server-focused apps the solutions to this problem have been tried and tested. But, how do we achieve this when it comes to HTML5 single page apps?

In this talk you'll learn about the main concepts we have applied, how we have applied them - and how you can too - to achieve what might sound like the impossible.

BladeRunnerJS is an open source developer toolkit and lightweight front-end framework that has helped the company I work for (Caplin Systems) ensure that a 200k LoC JavaScript codebase hasn’t become a tangled mess of unstable spaghetti code (with bacon bits). This codebase is then delivered to customers, along with around 50k LoC example functionality for them to build upon, and they're expected not to turn that into a tangled ... you get the idea.

The spEEDO project aims to augment existing debug APIs (such as GNU's RSP and ARM's Coresight) with a power component for reporting and tracing energy use in multicore systems-on-chip. Energy is logged per IP block and per application thread and reports are made available to the operating system, to applications programs and over the debug interface. The aim is facilitate optimizations for energy-efficiency at all stages of software and silicon development.

Dr Greaves will report on the current state of the API and solicit adoption by and improvements from the SoC community.

Dr David J Greaves.

University of Cambridge Computer Laboratory in Collaboration with Ultrasoc Limited.

All the cool cats are using Redis and with reason: It's fast, it's robust, it's easy, and it's web scale. Redis is powering sites like twitter, instagram or pinterest, but you can also benefit from the power of redis even in a more modest project.

In this session I will talk about what is redis, what you can do with it, how you can use it from your application, why you should be using it already and some common patterns when dealing with it. I will talk about:

what REALLY FAST means Redis data structures

How twitter, pinterest or instagram use redis.

queuing slow operations using redis for cross-language development atomic counters and generating sequences dealing with temporary data in your application redis as a cache how to store relational data in a non relational data store interesting problems when distributing your application.

Using Lua scripting for atomic operations

Running Android on low-RAM systems can present unique challenges. Tuning Android for these systems requires a knowledge of general Linux memory management and the memory tuning mechanisms specific to Android. This presentation will explore the tools and knobs available at all levels of the system to optimize and configure Android for devices at, or below, the recommended available RAM.

VEX, as part of Valgrind, is well-established in the world of dynamic analysis. However, there are certain questions that are best answered by symbolic analyses. In this talk I will describe the ideas behind symbolic analysis, detail challenges frequently faced when attempting to implement it, and introduce the work ongoing at UC Santa Barbara to use VEX to address these challenges, and implement a large-scale symbolic analysis system.

VEX is designed and widely used in dynamic analysis, in the form of Valgrind. Barring some implementation issues, VEX's side-effects-free, mostly-architecture-independent implementation provides an effective base on which to build non-dynamic analyses, as well. Specifically, we have used VEX to implement architecture-independent static and symbolic analyses.

Symbolic analysis is an active area of research, and many challenges are faced when attempting to implement it. These challenges include tradeoffs between tractability and precision when reasoning about symbolic memory, the NP-completeness of the underlying SMT-solving algorithms, difficult-to-analyze program actions, and many others. Some of these challenges are unsolveable, but compromises can be made to achieve useful results with symbolic analysis. This talk attempts to outline these challenges, describe some solutions, and provide a guide for parties interested in symbolic analysis with VEX.

Greenlet is a pretty well-known way for implementing cooperative micro-threads in Python, but how does it actually work? How is it similar and different from Stackless? We'll take a peek at how PyPy implemented it using a small library called 'stacklet' and how the python-fibers project takes advantage of it to build a similar project.

Copyleft licenses, particularly the GPL and LGPL, are widely used throughout the Free Software community. Over the last few years, recent debates have led many to various conclusions about the popularity of copyleft. This talk will discuss where copyleft stands today, how it interacts with the modern Free Software world, and how copyleft advocates may need to adapt to the future of Free Software licensing.

Copyleft licenses, particularly the GPL and LGPL, are widely used throughout the Free Software community. However, recent for-profit corporate interest in Free Software development has led to a renewed preference toward non-copyleft licensing by for-profit entities. Meanwhile, many for-profit entities that do use copyleft for their own software now do so in a manner that most copyleft aficionados find, at best, distasteful and at worst, abusive.

A long-standing truce exists in our community between fans of non-copyleft licensing and copyleft. No one in the copyleft communities disputes that non-copylefted Free Software is an important part of our community. However, copyleft faces new challenges that make past debates about the appropriateness of copyleft seem quite minor by comparison.

This talk will discuss all aspects of the complicated situation facing copyleft, including younger developers apparent preference for non-copyleft licensing (as expressed, in part, in the "post-open source" debates), the widespread and common failures for companies to comply with GPL's relatively easy requirements, and how licensing choices are today, unlike in the past, rarely in the hands of individual developers, but instead their corporate employers.

At the moment the most common solution to bring Linux embedded devices into the Internet of Things world requires a gateway or border router device. These devices use a separate IEEE 802.15.4/6LoWPAN Stack from ContikiOS, TinyOS, etc.

The somewhat misnamed linux-zigbee project aims to implement the IEEE 802.15.4/6LoWPAN functionality (but not ZigBee) inside the Linux kernel so that you can bring a Linux machine into the Internet of Things world easily. The required hardware is an IEEE 802.15.4 radio frequency module which is typically connected via SPI or USB. On top of the 6LoWPAN stack you can run any IPv6 userspace software.

The main goal of the linux-zigbee project is to support the IEEE 802.15.4 MAC layer with 6LoWPAN on top in Linux kernel. Without linux-zigbee, a gateway or border router device running a separate IEEE 802.15.4/6LoWPAN stack was required. These devices are connected via ethernet, SLIP or USB-RNDIS to Linux. We want to bring the IEEE 802.15.4/6LoWPAN functionality into the Linux kernel which makes unnecessary to run a different stack on a separate device.

The project started in 2008 and part of the work have already been included in the Linux kernel. At the moment the Linux Kernel supports various IEEE 802.15.4 radio frequency modules which are typically connected via SPI or USB. With the project's userspace tools you can setup a WPAN interface with a virtual LoWPAN interface on top. This LoWPAN interface translates an IPv6 header to a 6LoWPAN header and vice versa.

In the last year the 6LoWPAN implementation in Linux became more RFC compliant so communication in a heterogeneous network becomes possible. The IEEE 802.15.4 stack only supports data frames right now. The 6LoWPAN stack supports IPHC, UDP compression/uncompression and fragmentation at the moment. A limited RPL python implementation was released which adds a basic support of Routing Protocol for Low-Power and Lossy Networks. The libcoap library adds support to run CoAP applications in userspace.

There is a draft for supporting 6LoWPAN on Bluetooth. We are working with the Bluetooth community to support 6LoWPAN in Linux kernel. Another wish is to support RFC6775 for 6LoWPAN neighbor discovery optimizations which isn't implemented yet.

This talk is for developers who are interested in the actual state of IEEE 802.15.4 and the 6LoWPAN stack under Linux.

What is new in your Open Source project? The answer to this question is both important and interesting for developers and users. When the project is small, browsing the revision system log is an easy way to get the answer. Then the project becomes a success and the answer is getting more complicated to obtain.

In this talk we would like to show how we produce the KDE Commit Digest, the weekly oveview of the developer activity in KDE. We will show the whole system. This starts with the infrastructure that allows semi-automatic classification. Then we have the KDE revision control system and the special tags developers may put to mark the most important changes. We will finish with the team that handles this by reviewing, writing the summary and publishing.

Automation is eating the world. No longer can you run systems with out any level of automation. But how do you build that automation so that it will work in a mixed distro environment? This talk will cover how to build cross distro automation using Chef.

ANSTE is an open source tool designed to reproduce complex scenarios and simplify the execution of tests in several machines.

ANSTE, uses libvirt (KVM) to virtualize networks and machines and then run on them tests written in any scripting language. This allow you to test a lot of different scenarios with different setups in an easy way.

It is prepared to run additionally WebDriver tests to test web interfaces. For example, it has been used to test the MySQL cluster or complex OpenVPN scenarios configured with Zentyal.

Jan-Simon Möller will introduce the audience to the LLVMLinux project which goal it is to compile the Linux Kernel with the compiler tools provided by the LLVM project (clang). He will talk about the steps needed to compile the Kernel itself, the issues found during this endeavour and the status of upstreaming patches to the Kernel and the LLVM project.

The Allwinner series of System on Chip (SoC)'s has a healthy community around this interesting little chip. This talk will bring interested listeners up to speed in how it all got started and where we, as a community, are today.

In 2011 Allwinner surprised the market with its low-cost Cortex-A8 A10 SoC. In 2012 the A10 and it's smaller brothers the A10s and A13 where found in nearly all Cheap tablets and android-tv-sticks. This alone attracted a lot of hackers and enthusiasts to work on the Allwinner A-series of SoC's.

A few of these hackers started to form the linux-sunxi.org community supporting, hacking and even Reverse Engineering these SoC's.

We are excited to share with you in this talk of what has been done so far and where we are heading. One of the most famous hackers amongst the Fosdem crowd would have to be Luc Verhagen (libv) with his lima work, which he did a lot of on A10 hardware. But many others have worked since then on these little SoC's and the most important recent breakthrough is the Reverse engineering of the CedarX Video Processing Unit (VPU) which makes it possible to playback accelerated mpeg and h264 video with zero closed source blobs or firmwares which in itself is an amazing feat.

Taking this opportunity we welcome you to join us to learn more about these amazing SoC's, see what they are capable of in a little Demo and how you could potentially contribute come join us at FOSDEM 2014.

Discussion of Intel BayTrail SoC architecture from a graphics perspective, including overview of render engine, display engine, memory architecture characteristics, and current status in Linux. Hopefully the presenter will have some sample platforms for people to play with after the talk.

The Intel BayTrail platform incorporates a new, out of order Atom CPU, an Intel HD graphics engine, and various IP blocks to support both tablet and notebook platforms. This talk will give an overview of the new hardware features, and the status of the graphics driver support in Linux.

New or unknown Ganeti functionality. We will discuss: - monitoring daemon - confd - network management - ext storage

Ganeti is an open source cluster virtualization manager that's been presented at FOSDEM previously. This talk will discuss what's new in the Ganeti codebase since last year, and also focus on less widely known features that might make life easier for current and future adopters. We will also provide hints into what's coming soon, in the current release candidate, beta and bleeding edge version.

This talk gives a close look at second wave HTML5 features around video delivery — specifically, mediaSource API / adaptive streaming, encrypted media extension and WebRTC. We look at open tools and techniques for transcending platform limitations and delivery these experiences across increasingly diverse set of devices and platforms. Real world usage examples are highlighted from experience with open tools we have built and integrated.

This presentation outlines real-world production usage of second wave HTML5 video features with a focus on technical integration into arbitrary application contexts and the trade offs for targeting a given feature set.

We begin with a short review of challenges in the first wave of HTML5 video; codecs, consistent JS API and lack of unified adaptive streaming support standard. We then transition into HTML5 Part Dux and see how "the sequel" is a lot like the original with respect to a powerful new set of features but with equally impressive platform fragmentation and API inconsistencies. We highlight the compounded challenges of the entrance of additional mobile and smart tv platforms generating more device targets to support then ever before.

We review open video platform solutions developed to bridge these limitations on native devices. Specifically we look at the technical architecture of a native video component that we have built to bridge android and iOS web view limitations in an native environment while seamlessly leveraging a feature rich HTML5 player platform.

We also review the current state of mpeg-dash and highlight technical inconsistencies in implementation that drive the use of shared code libraries such as dash.js. We preset our production dash.js usage for VOD, Live and associated encrypted media extension options for content controls, along with technical implementation details to help inform integration options and trade offs.

Finally we look to WebRTC and the types of experiences it can enable and how they can be delivered within the contemporary platform ecosystem. We look at technical approaches towards enabling usage and cross platform delivery options.

Since its initial incubation, Giraph has turned into a different beast. It is now a solid, full-featured tool used in production at many companies that need to analyse massive graphs. The success of a data analysis tool relies on the usability if its programming API and its ability to play well with the ecosystem of data stores.

In this last year, much has been done in this aspects, with a new programming API that allows composable jobs, and scripting support. You can now write Giraph applications that will run over billion of vertices with 20 lines of python code.

Moreover, Giraph is now able to read and write graphs from any Blueprints-compatible graph database. Furthermore, thanks to Gora, it can read and write data modelled as graphs from a large set of NoSQL (even SQL!) stores.

In this presentation, I will focus on these new contributions to Giraph, namely its python API and the rexster and gora input formats.

I will show samples or working code, and run a demo where I compute a graph computation expressed in python over a graph stored in a graph database.

Free / open source software projects are producing, as a byproduct of their usual activity, a great deal of data about how they develop software, and about how their community coordinates. Development and community metrics can be derived from this information, which can be later visualized in project development dashboards. The talk will show how tools in the *Grimoire toolset can be easily used to build those dashboards, from data retrieval up to analysis and visualization. As examples, dashboards for real projects, such as OpenStack, Puppet and MediaWiki, will be used to show how to interpret the data, and get insight about their development processes and their community. Examples of specific areas in which metrics are useful to track important parameters of the project will also be explored in detail, such as code review performance, time to close tickets, or the structure of the community.

FLOSS (free, libre, open source software) projects are usually developed in the open. A lot of information about their inner life is available in their development repositories: source code management (aka version control), issue tracking (aka bug reporting) systems, mailing lists, IRC channel logs, etc. This information can be organized and analyzed, and be used to gain understanding about how the project is performing, about the processes their developers are using, and in general about how it is evolving.

The kind of quantitative analytics that can be obtained from these repositories allow also for a direct tracking of several parameters that can characterize specific aspects of software development. The impact of changes in project policies or uses can therefore be evaluated quantitatively, and be observed and tracked.

Fortunately, having these analysis done for a given FLOSS project is becoming an easy task. Some web-based services, such as Ohloh, are already producing some of them, and some platforms, such as GitHub and Jira, also allow for tracking some parameters. In this talk we will present Grimoire, a FLOSS platform allowing anyone to do their own metrics dashboard, from data retrieval from repositories to analysis and visualization of the parameters of interest. Grimoire is composed of two main components: MetricsGrimoire, a set of Python tools supporting most common development and community repositories, and vizGrimoire, which provides an R package and a JavaScript library for analyzing and visualizing the data.

As a part of the talk, the whole process of how to analyze repositories using *Grimoire will be briefly described. As case examples, some well known projects, such as OpenStack, Puppet or MediaWiki, will be explored based on the information from their dashboards, which are already being used by their communities. In addition, specific areas in which metrics are useful to track important parameters of the project will also be explored.

More information about MetricsGrimoire

More information about vizGrimoire

Some of the dashboards that will be presented in the talk are:

• OpenStack Development Dashboard

• MediaWiki Community Dashboard

Testing network applications correctly is hard. This talk will show how to create a fully isolated network environment for client and server testing on a single host, complete with synthetic account information, hostname resolution, and privilege separation.

The libc wrapper project aims to help client/server software development teams willing to gain full functional test coverage. It makes it possible to run several instances of the full software stack on the same machine and perform locally functional testing of complex network configurations. Daemons run with privilege separation and required user and group accounts, irrespective to the hosting system. The libc wrapper project does not require virtualization and can be used to build environments with different operating systems. The project consists of a socket wrapper, NSS module wrapper (users, groups, hosts), and a (s)uid wrapper with support for GNU/Linux, BSD, OSX, and Solaris.

If you have been looking to use SQLAlchemy in one of your projects, but found the documentation a bit overwhelming then this talk is for you.

If you have used SQLAlchemy but feel there are some holes in your knowledge of the library, then this talk is for you as well. The idea is that during this talk you bring your laptop with you, and make sure you have SQLAlchemy installed. At the beginning of the talk, we fire up our Python interpreter and start to explore the library in a structured way. In the next 25 minutes, we'll go hands on through the various parts of the SQLAlchemy. We try out the concepts of each part of the library and make sure the basics are well understood.

This event will briefly describe the amazing Wine unit test framework, along with the full Windows Test Bot. It will amaze you so much that you will joyfully leap up to answer our resounding cry for help. This is a particularly good opportunity for Windows developers to help the Wine project.

The Internet of Things (IoT) is being used for lots of personal data, but what little authentication and authorization is mainly being done using traditional centralized role-based approaches. This talk shows how we can use Federated identity and access management approaches such as OAuth2 with MQTT and CoAP to support IoT.

The Internet of Things and Machine to Machine are growing areas, and security and privacy are prime issues. In this session we will examine the security challenges around using M2M devices, with special reference to Authorization and Authentication. Much of the IoT is used for personal systems, and so there is a strong need for person-centred identity and access management. The OAuth2 protocol is gaining wide acceptance in the Web, and has been designed to support federated identity, personal delegation of access control and dynamic permissions.

We look at how we can use OAuth with MQTT and CoAP. We will use a combination of open source hardware (based on Arduino) and open source software (including Mosquitto and WSO2 Identity Server) to demonstrate an Arduino based IoT device interacting with MQTT based systems using OAuth2 bearer tokens.

The session will cover: - Challenges with IoT security - Using OAuth2 to support federation and user-directed authorization - Issues and areas for further work - Future directions

The session will include a live demonstration of Arduino and Eclipse Paho interoperating secured by OAuth 2.0.

Osmocom stands for Open-Source MObile COMmunication. It's an umbrella project for several sub-projects that focus on implementing various telecom standard. A growing part of these are using SDR and theses are the the ones that will be presented in this talk.

Among theses are rtl-sdr, a library to use cheap dvb-t dongle as SDR receiver; gr-osmosdr, a GNURadio source block to support multiple capture hardware easily in your apps; osmo-tetra, an sdr implementation of a TETRA receiver; osmo-gmr, a protocol stack for this satphone standard; gr-fosphor, a GPU accelerated spectrum visualization block for GNURadio.

AngularJS is vodoo, big vodoo. How much of Angular's goodness could be fitted into a library the size of Backbone (10x smaller)? Cute is a attempt to do just that.

In the talk I'll give an overview about Escape and explain the most important concepts. Especially, I'll present the virtual file system that the kernel provides and that is among others used for getting access to drivers.

Escape is a UNIX-like microkernel operating system which I'm developing since October 2008 as a hobby. It runs on x86 and the two rather exotic architectures ECO32 and MMIX. The kernel provides processes, threads, memory management, a virtual file system and message passing. The userspace consists of drivers/services (ATA/ATAPI, ROM-disk, filesystem with support for ext2 and iso9660, UI-manager, window-manager, virtual terminal, keyboard, mouse, PCI, RTC, VGA, VESA and a few others), libraries (C, C++, GUI and others), simple versions of the well known UNIX tools (ls, ps, cat, head, less, ...) and a GUI.

As the prominent open-source data center virtualization solution, oVirt has many features that help you virtualize data center and cloud offerings. Sometimes a feature might be needed to extend oVirt's capabilities, but even though oVirt is open source, you might want to provide a quick and dirty solution..

Mike Kolesnik from Red Hat will show you how you can extends oVirt's capabilities with ease throughout the oVirt stack - UI, engine and host.

Developers are welcome to join us in this session to learn how you can leverage oVirt to suit your virtualization needs.

Find out why you care about LSB, LANANA, FHS, LSB 5, LF, RPM5

Why do you (an attendee at FOSDEM) care to come to a lightning talk on:

    LSB, LANANA, FHS, LF, LSB 5, RPM5

Everyone who has been involved in FOSS knows that a new project needs to ship running code at once, or be passed over as 'not relevant', 'not ready', or plain old 'vaporware'. But everyone in FOSS also knows that once credibility is established by a project or a distribution, future updates and releases can have the leisure of a road-map, and not shipping 'until it is ready', because there is not the commercial pressure of a sponsoring company needing to push out potentially unfinished work to meet a marketing schedule. This also is expressed in the 'time boxed' vs. 'feature complete' release stabilization approaches. Agile methods and 'rolling releases' and the emergence of the tension between 'latest and greatest' vs. 'Enterprise' and 'LTS' permeates Linux-dom

The other common attribute of FOSS projects, is that the documentation seems always to be stale, always incomplete, and often wholly absent. How can a consumer of a project (individual or commercial) know what to rely on, or to 'write to'?

Fortunately, the ATT variant of Unix was produced by a designer, manufacture, and provider of telephone grade hardware, where manuals were not just 'nice to have' but also an essential part of the deliverables. The 'Unix wars', harsh as they were to adoption by end consumers of operating systems, also were 'fought in the trenches' of standards committee meeting rooms

And so POSIX and Unix-like expectations are quite well known, and so the need for formal testing for completeness and mandatory behaviors, and The Open Group carried some of the early hard work of writing and maintaining the test suites needed. Later the Linux Standards Base ('LSB') emerged as the reference standard, open and non-commercial, where a Independent Software Vendor, an end user, and a Distribution could each look for the needed interfaces, the certification of portability, and the benchmark of what to provide for inter-operability, in the Linux part of the 'nix world

LSB has been one of 'documenters', along with the minimal man page practice of Debian, and the Linux Documentation project ("LDP"). LSB was content to follow along and has a niche (perhaps not wanted by others, but so what?), and gravitated into sponsorship under the Linux Foundation ("LF)") in due course. Also, pulled into orbit was the Linux Assigned Names and Numbers Authority ("LANANA"), which recently has had ITS sub-project the File Hierarchy Standard {"FHS"} some need for extension of its specification to provide a way for package vendors, projects, and sub-parts from a vendor to obtain 'guaranteed uniquely managed' name-space paths in the file-system

The LSB has followed along, documenting expectation and tracking changes, so that expectations are explicit, tests are freely available, and that users of conformant software can count on portability as they move between distribution environments. Motif has pretty well died off, but Gtk and Qt came along; System V initscripts are slated for the dustbin as upstart and systemd fight it out. and so the recent update for LSB -- its new major version: 5.0 has been in beta, and went gold on (TBA)

So, come learn about how to write portable applications, or how to provide an environment which fosters uses of your project rather than another toolkit.

One of the items that was cut out of 'LSB 5.0 initial' due to incufficient resources, was an uplift of the RPM (LSB variant, which lacks triggers, and some other aspects which time has shown are needed -- ldconfig management and SELinux hooks come to mind). Also new compression schemes have come out of patent or emerged; new database stores for all the 'book-keeping' which a distribution's package manager needs. RPM5 has been exploring this space for a decade, and a companion presentation by Jeff Johnson has been proposed for FOSDEM 2014 as well, and will be briefly reprised here

This talk will illustrate the power and flexibility of Graph Databases to help in the overall analysis of biological data sets. Davy will show how to build a visual exploration environment that helps researchers at identifying clusters within various biological data sets, including gene expression and mutation prevalence data. Additionally, he will demo BRAIN (Bio Relations and Intelligence Network), a powerful data exploration platform that combines various scientific data sources (including Pubmed, Swissprot and Drugbank). It uses a graph database under the cover to both store and enable powerful querying capabilities that provide key insights and deductions.

I will discuss how to measure energy consumption and show off the University of Bristol-designed energy monitor. This board can sample energy use with up to 6 million samples per second and the designs are open. This will allow fine-grained measurements of energy consumption, and power profiling of applications to find the energy hot-spots of a program

During the last few months of 2011 the Xen Community started an effort to port Xen to ARMv7 with virtualization extensions, using the Cortex A15 processor as reference platform.

The new Xen port is exploiting this set of hardware capabilities to run guest VMs in the most efficient way possible while keeping the ARM specific changes to the hypervisor and the Linux kernel to a minimum. Developing the new port we took the chance to remove legacy concepts like PV or HVM guests and only support a single kind of guests that is comparable to "PVH" in the Xen X86 world.

Linux 3.7 was the first kernel release to run Xen on ARM as Dom0 and DomU. Xen 4.3, out in July 2013, is the first hypervisor release to support ARMv7 with virtualization extensions and ARMv8.

This talk will explain why ARM virtualization is set to be increasingly relevant for the automotive industry in the coming years. We will go on to describe how Xen exploits the strengths of the hardware to meet the requirements of the industry. We will illustrate the early design choices and we will evaluate whether they were proven successful or a failure.

The goals of the talk are to:

• describe the Xen architecture
• explain how Xen on ARM is different from Xen on x86

• provide a status update of the project

• explain what are the benefits of virtualization for the automotive industry

• explain what Xen provides for this use case that other hypervisors do not

MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.

This talk is about how we can use interfaces in Go to write testable code that can be easily modified, or "grows with grace".

Go's interfaces — static, checked at compile time, dynamic when asked for — are, for me, the most exciting part of Go from a language design point of view. If I could export one feature of Go into other languages, it would be interfaces.

— Russ Cox

We'll cover the following topics:

• Taking advantage of Go's automatically satisfied interfaces
• Choosing third-party packages that are easy to extend for your own purposes
• How interfaces are used in Go's standard library
• A look at the internals.

There will be a mixture of practices I've seen used in third-party packages and the standard library, and also some I've successfully applied to our own large codebase.

When starting to contribute to LLVM knowing the technical steps and especially the community habits can make the first (and upcoming) contribution a lot easier and the contribution process will become a more positive experience. This talk will discuss technical points such as your first patch for LLVM, how to get +w permissions, the various workflows, but also more soft skills such as 'how can I find a reviewer for my patch', 'should I review patches myself', or 'what is this the right strategy to add a larger feature to LLVM'?

Throughout its 20-year history, Debian had to face a number of legal issues, in all fields of the so (improperly) called "Intellectual Property". From trademarks to patents, from copyright to export control and embargoes, Debian didn't miss a single pesky issue. In this talk we review some of the most relevant legal issues that Debian has faced in recent years and how the project has responded to them. Doing so is a chance not only to share legal best practices with other Free Software communities, but also to highlight the policy annoyances that widespread legal systems imposes on radical Free Software communities such as Debian.

In this presentation we will start from basic CMOS power consumption factors. We will use that as the basis to explain the various possibilities to balance power versus performance. We will then continue explaining how these techniques are implemented both in the SoC hardware and in the the operating system and application software. Android, maemo, OMAP and Tegra will be used to illustrate the techniques.

We will start by explaining which factors influence power consumption in CMOS chips. We will then explain a number of commonly used techniques to control the power versus performance balance such as clock and powergating, clock and supply voltage scaling and heterogenous multiprocessing. We will continue explaining how these techniques are implemented in linux using various frameworks such as cpuidle, cpufreq, common clock framework, runtime PM, generic powerdomains, device QoS constraints, system suspend. We will then discuss how application code affects the device power consumption and discuss how Android and Maemo handle this. We will also discuss various debugging mechanisms and tools such as powertop, ftrace and other information in linux sysfs and debugfs. We will also explain hardware techniques we have used to gain insight in the system operation beyond the view of software.

The SysGrove® project is mainly based on PyQt4 and SQLAlchemy. Application development and enhancement is ongoing and as a matter of fact, the database scheme is changing quite often with many migrations per day.

As the minimal set of data to test and run the application is quite important, we use Alembic to handle database migrations. It is rather simple to put Alembic in place and to run automatic migrations. The process is well documented in Alembic itself and has been detailed in some places on the web (http://www.chesnok.com/daily/2013/07/02/a-practical-guide-to-using-alembic/ for example). However it is more difficult to find examples of complex migration problems. Alembic auto-migration only handles the following cases : - Table additions, removals. - Column additions, removals. - Change of nullable status on columns. - Basic changes in indexes and explicitly-named unique constraints Combining Alembic together with SQLAlchemy provides many ways to handle more complex cases. In this talk, we will deal with examples such as : - rename a column in a table - adding an Enum column - add a none nullable columns in a table containing data - dealing with sequences - updating data from a migration scripts - ...

http://sysgrove.com/ http://pyqt.sourceforge.net/Docs/PyQt4/index.html http://www.sqlalchemy.org/

Most people still think of syslog-ng as a logging system with a flexible configuration language. It is now databases, message parsing, mongodb, JSON, message queuing and a lot more.

Over the years, syslog-ng has evolved from a flexible and reliable logging system into a feature-rich log-processing tool. It's not just store and forward anymore, for example, with syslog-ng you can: * Process and parse the body of messages to find important information and send e-mail alerts for specific events * Receive structured JSON messages from your applications and store-them in a schema-free MongoDB NoSQL database * Publish your messages to different message-queuing systems, for example, STOMP or AMQP * Collect real-time statistics from your hosts and applications using the redis or riemann destinations All of these illustrated with short real life examples, how they can be used during development or operating your servers.

Guix is GNU's package manager and distribution. It seeks to empower users in several ways: by being a dependable system foundation, by providing the tools to formally correlate a binary package and the "recipes" and source code that led to it, by allowing users to customize the distribution, and by lowering the barrier to entry in distribution development.

This talk will describe the features and foundations of GNU Guix as a package manager. It will report on the current status of building a stand-alone GNU distribution, and outline design goals that set it apart from existing distros.

Guix is GNU's package manager and distribution. Its goal is to be a foundation for the GNU system that is dependable, hackable, and liberating.

Guix is a dependable package manager in that it supports transactional upgrades and roll-backs---valuable features pioneered by the Nix package manager it is based upon. The underlying functional package management paradigm, where packages are built in isolated containers, maximizes chances that builds are bit-reproducible---allowing users to compare independent builds of a given package, rather than relying on a single distribution point for binaries.

Packages are declared in a high-level fashion, using a domain-specific language embedded in the Scheme programming language. This is the first step in making it hackable to our eyes: packagers do not even need to know Scheme to write a package definition, yet the full power of Scheme, of GNU Guile, and of the Geiser programming environment is available. From a programming viewpoint, Guix and the GNU distribution are just a bunch of "normal" Guile modules, some of which export "package" objects---one can easily write Guile code that builds atop the distribution, customizes it, or otherwise fiddles with packages.

This feature set serves one goal: to put users in control. We are putting together an operating system made of software that respects the user's freedom---GNU's goal as stated 30 years ago. By allowing users to know exactly what dependencies and build scripts led to a given binary, the functional package management paradigm increases the control users have over the software they're running. By offering a consistent view, tool set, and APIs, we hope to make it easier for users to exert their freedom to adapt the software to their needs.

This talk will present these features, the underlying foundations, and our motivations. We'll report on the project's status after more than a year of development, and discuss what's cooking in the GNU system.

Nouveau is an open-source driver for NVIDIA GPUs developed through reverse engineering by the community. This talk will discuss the achievements of the driver, what happened these last 2 years, what we are working on and what may change in the future. Special emphasis will be put on power management as it is the most-lacking feature in our driver. Some demos and Q&A will close the talk.

Talk on how XMPP fit into the world of IoT. The big advantages, technologies, possibilities, and differences.

The XMPP Standards Foundation has accepted a series of extensions for internet of things available at http://xmpp.org/extensions/.

The talk is about how XMPP could be a solutions to several of the challenges in deployment of massive IoT

This talk gives an example on how to connect realworld devices using the extensions XEP323 and XEP325

The session is also an inspiration for the afternoon hacking session where people are encouraged to try the code out and

Gives a hint on how a Semantic web approach can be added in a secure way.

Let's explore the fully open source technology stack of Wikipedia and Wikimedia's other projects, and the many ways to get involved in making the sum of all knowledge available to every person on the planet.

Wikipedia and the other Wikimedia projects serve more than 500 million users every month. That's about 20B pageviews/month (4B on mobile). The Wikimedia Foundation does all its work as open source development. From being entirely volunteer-driven, it has grown to employ a staff of 100+ in engineering, analytics, design & product development. What do these folks do? In this session we'll talk about:

• templates, Lua scripting, and the promises and challenges of visually editing Wikipedia on desktop and mobile clients;
• task recommendation and onboarding for new users, and how to build a modern discussion/collaboration engine that won't turn Wikipedia into Facebook;
• Wikimedia Labs, the MediaWiki API, OAuth, MediaWiki extensions, user scripts and gadgets - the many ways to be part of the development and operations community.

The talk starts with a short introduction of the Barebox bootloader. Recently, barebox gained several new features: one of the most prominent is multi image support with full initialization from the open firmware device tree. Using this method, it is now possible to generate bootloader binaries for a whole family of devices, just by writing an open firmware device tree. Porting Linux to new hardware has never been so easy.

Other new features include support for the freedesktop.org bootspec: This method to define "boot target" makes it much easier to realize redundancy-boot setups and in-system upgrade mechanisms for industrial devices. For community hardware, the bootspec makes it quite easy to boot standard distributions without taking care of all the ARM specialties.

GNU Radio is a powerful tool for signal processing of any kind. It is very much suited for setting up any kind of communication link. In this tutorial, we will discuss how to set up a PHY that can be attached to an application and MAC layer in order to experiment with arbitrarily configured wireless networks.

Tutorial overview: * OFDM blocks basics * How to set up links between nodes * How to start working on MACs

Bio4j is a high-performance cloud-enabled graph-based bioinformatics data platform. It integrates most data available in UniProt KB (SwissProt + Trembl), Gene Ontology (GO), UniRef (50, 90, 100), RefSeq, NCBI taxonomy, and Expasy Enzyme DBs. Data is organized in a way semantically equivalent to what it represents in the graph structure, and thanks to this, queries which would even be impossible to perform with a standard Relational DB can just take a couple of seconds with Bio4j.

This year has seen important updates and new developments on Bio4j. It now includes 1.216.993.547 relationships and 190.625.351 nodes, almost triple the figures from one year ago. We have introduced a new level of abstraction for the domain model, by decoupling the inner database implementation from the relationships among entities themselves. Interfaces has been developed for each node and relationship present in the database, including methods to access both the properties of the entity it represents and utility methods that allow to easily navigate to the entities that will be linked to it.

Implementing that set of interfaces we have developed another layer for the domain model using Blueprints, the de-facto graph data model standard, making the domain model independent from the choice of database technology. Building on that, we now offer specifically tuned data binary distributions for TitanDB, yielding a dramatic increase in performance due to vertex-local edge-typed indexes.

Bio4j is open source, available under the AGPLv3 license.

mbed is an open platform for developing ARM-based low power embedded systems (with a focus on IoT devices).

This talk will provide an overview about: * why you might want to base your next low power device on the mbed platform * how to start developing only using the Free GNU GCC Toolchain and the open mbed SDK (Apache v2) * the measuring of the energy consumption of an mbed

In this talk, we will present the state of the art and history of volunteer and, in particular, browser-based computing, will make a general introduction to evolutionary computation, and then how this type of algorithms can be adapted to run on ephemeral, distributed, asynchronous, and heterogeneous nodes. We will present our NodEO and jsEO evolutionary algorithm libraries and the result of some experiments using this platform. Finally, we will generalize and show a general methodology for doing scientific computing using JavaScript.

Blare is a model for policy-based intrusion detection systems. It works by tracking information flows. The model has been implemented for the Linux kernel as well as for the Java Virtual Machine and Android. This talk will present the model and show how we implemented it for the kernel as a Linux Security Module in order to leverage existing hooks to intercept system calls.

Blare is a family of policy-based intrusion detection systems (IDS). These IDSs are based on a common information flow monitoring model. The user defines the policy by specifying authorised flows beforehand and these IDSs dynamically check this policy in different types of systems. KBlare is an implementation of this model at the Linux kernel level. It is a security extension using the LSM framework to intercept system calls and add meta-information, called security labels, to the different types of information containers in the system (files, memory pages). KBlare updates these labels depending on the flows it tracks ie. based on executed system calls. It throws alerts whenever one of these flows does not satisfy the policy ie. whenever one of the security property becomes invalid for a container's label. We will briefly present the theoretical model and proceed to explain how we implemented it in the Linux kernel. Using the LSM framework, we intercept system calls and deduce information flows. We will also show a brief demonstration of KBlare detecting an intrusion.

For several years now, oVirt has managed Virtual Machines. Then came the question: can you run oVirt inside a VM, which in turn will be managed by the hosted oVirt? In this session we'll look at the intricacies of an egg hosting it's parent chicken. We'll cover the various aspects starting with installation, going through standard operations, and ending with high-availability for the hosted engine. Participants will be able to get insights of this unique setup, which will save them a physical server (or even two) while allowing standard flows to run the same way they did in the past years.

Developers tend to ignore that users can be more creative than them. Use their debugging skills for your own benefit: post-mortem debugging is one of the most important features your web framework can provide.

This talk will cover some of the simplest practices and available tools for debugging on production environments and to immediately improve quality of your web applications.

Bring along your applications and have their energy consumption measured on a pre-instrumented Arduino, Raspberry Pi or BeagleBone. Alternatively, bring along your own design on a breadboard and we'll hook up a PowerSense shield to measure the energy usage.

We are a group of engineers from Red Hat's Desktop QE team and we would like to discuss stand-alone application testing on Linux. During this workshop we'd like to show existing workflows of application testing, discuss testing tools, and overall influence of quality engineers on open source software development process.

This workshop is meant to be discussion point for every person interested in improving quality of open source application. We would like to start with sharing Red Hat's experience and approach to testing and automation across several teams, components (packages) and other interested parties.

Topics to be covered (no specific order):

• Success stories (Evolution, NetworkManager)
  • Bugs found by automated tests
  • Code coverage improvement
• Static code analysis - cppcheck, clang etc.
• Debugging tests in VM on Jenkins
• 'Run per commit' vs 'daily runs' - Evolution and NetworkManager experience
• Downstream vs. upstream tests
  • Upstream: gnome-continuous, installed tests
  • Downstream: beaker and jenkins for fedora project
• Integration tests on Beaker. Fedora's experince
• Behaviour driven testing
  • Abstraction and step re-use, which simplifies testing with several frontends ( GTK/QT vs TUI vs CLI testing)
• Dogtail and accessibility:
  • Upstream tests in PiTiVi

We'd like to invite developers and QA-involved participants interested to discuss advanced ways of testing and auotmation for standalone open source applications

How do modern connected cars use and interact with FOSS? How can an industry adopt the best practices from Open Source and Free Software? Its more than just using Linux and incorporating environments like Android, you have to engage communities. How do you as a developer engage?

This talk will describe how you can engage with various initiatives in the industry. We'll also describe the landscape of various collaboration projects and alliances to help negotiate a rapidly changing ecosystem.

In the Big Picture, FOSS has had a huge impact. This talk will describe the strategic landscape of the various alliances and projects that allow individual developers to connect to the vehicle. We'll also look at the specific technologies and protocols that are being brought forward in the open that are concrete examples of how they bridge the two communities (FOSS and automotive.) Topics like Ethernet Audio Video Bridging (EAVB), Android for In-Vehicle Infotainment, Qt, Wayland, and others will be addressed to show an example of FOSS' impact on vehicles.

In this talk we will see how one can use the clang libraries to build two practical tools. The first tool is an online C/C++ online code browser that uses clang to parse the AST in order to provide information about each token and build a cross reference database. [http://code.woboq.org] The second tool is a replacement for Qt's moc (meta-object compiler) which is used by Qt to provide introspection and enable signals and slots and the QML language, both as a stand alone executable or as a clang plugin. [https://github.com/woboq/moc-ng] The talk goes over implementation details and challenges encountered while developing.

Wireless connections have improved a lot lately and the data-rates and latencies that are now achievable with LTE make mobile broadband connections a key ingredient in every M2M recipe. But LTE mobile broadband connections in Linux-based systems are no longer setup using the good old AT+PPP pair. LTE-capable modems now use ECM-like network interfaces and even new control protocols, like QMI or MBIM.

This talk is about how the new LTE-capable devices are exposed in the Linux kernel (e.g. qmi_wwan, cdc-mbim...), and which user-space tools (e.g. ModemManager, libqmi, libmbim...) are available to control them. The talk will be a hands-on demonstration of how to use these modems with these tools, focused on what users need to do to use them properly, and also how developers can benefit from them to write new applications.

Mailvelope is a browser extension and allows to enhance existing web-mailers like Gmail™ or Yahoo™ with functionality to encrypt and decrypt mails. Mailvelope is based on the OpenPGP standard, offers key management, and is therefore compatible to existing PGP implementations.

The issue that Mailvelope wants to address is the low adoption rate of email encryption solutions. Although S/MIME and PGP have been around for many years, we see only limited proliferation.

It is our view that the most limiting factor of encryption applications are usability issues. Mailvelope wants to address this problem not by reinventing the wheel, but by tapping on established standards like OpenPGP and by making these more accessible.

The focus of Mailvelope are webmail providers. The extension comes preconfigured for major providers like Gmail™, Yahoo™, Outlook.com™ and GMX™ but is designed as a generic solution, that should work with any provider or website. Whenever an OpenPGP armored message is displayed in the browser, it will be identified as such and the user has the option to process and decrypt it. For the encryption scenario, we provide a secure way to compose the user message and then transfer it back to the website after it has been encrypted.

Mailvelope is currently available in the Chrome Web Store, a Firefox version is almost complete and expected for Firefox 27. The current feature set supports a basic mail encryption scenario and key management. Planned features are key server integration, signing of messages and attachments.

Bio4j bioinformatics graph database is modular and customizable, allowing you to import just the data you are interested in. There exist, though, dependencies among these resources that must be taken into account and that's where Statika enters the picture; a set of Scala libraries which allows you to declare dependencies between components of any modular system and track their correctness using Scala type system. Thanks to this, it's possible now to deploy only selected components of the integrated data sets, with Amazon Web Services deployments on hardware specifically configured for them.

Public compute clouds provide a flexible platform to host applications as a set of appliances, e.g., web servers or databases. Each appliance usually contains an OS kernel and userspace processes, within which applications access resources via APIs such as POSIX. The flexible architecture of the cloud comes at a cost: the addition of another layer in the already complex software stack. This reduces performance and increases the size of the trusted computing base.

Our Mirage operating system proposes a radically different way of building these appliances. Mirage supports the progressive specialisation of functional language (OCaml) application source code, and gradually replaces traditional OS components with type-safe libraries. This ultimately results in "unikernels": sealed, fixed-purpose images that run directly on a hypervisor without an intervening guest OS such as Linux.

Developers can write their code using their usual tools, only making the final push to the cloud once they are satisfied their code works. As they explicitly link in components that would normally be provided by the host OS, the resulting unikernels are also highly compact: facilities that are not used are simply not included in the resulting unikernel. For example, the self-hosting Mirage web server image is less than a megabyte in size!

We will describe the architecture of Mirage in the talk, show some code examples, and interesting benchmark results that compare the performance of our unikernels to traditional applications such as Apache, BIND and OpenSSH.

I've been involved with CloudStack as a project management committee member and I have been focusing mainly on the software defined networking implementations. When the OpenDaylight project started to become more popular integration between OpenDaylight and CloudStack was soon something on my wish list. This talk is about my journey to get support of OpenDaylight into the CloudStack project. This talk is partially about the technical implementation is getting the code bases to work together, but also on how ideas on implementation needs to be aligned between project for any interoperation to become a success.

The intended audience for this talk is developers who are interested in software defined networking or who are interested in hearing about some of the cross project hurdles one might have to cross when doing an integration.

This talk will be discussion on the lessons learned from driving an integration between two Open Source projects, OpenDaylight and CloudStack. The topics touched are the technical integration details on how both project think about networking and how this is aligned to allow for interoperation. The following topics will be covered in the talk:

• Networking model in CloudStack
• Networking models in OpenDaylight
• Integration issues, where are the brains at
• Integration issues, a CloudStack fanboy in an OpenStack crowd
• Integration issues, release pressure versus doing-things-right
• Current status of the integrations work
• The way forward

Technical depth of the talk will be all the way down to the OVSDB integration and implementation details of OpenDaylights modules structure. Mixed with a piece of my mind on how the communities reacted to this integration process.

In this talk YouTube Engineer Sugu Sougoumarane describes how they built Vitess in Go to help scale YouTube.

Vitess is a set of servers and tools primarily developed in go. It's meant to facilitate scaling of MySQL databases for the web. It's currently used as a fundamental component of YouTube's MySQL infrastructure. The talk will cover some history about how and why the team chose Go, and how it paid off. Sugu will also cover tips and techniques used to scale Vitess using Go.

Lumicall is a fork of the original Sipdroid SIP phone for Android.  As far as forks go, it is one of the more innovative ones, loading up the original project with cool features like encryption (TLS, SRTP, and ZRTP), ICE for NAT traversal and ENUM dialing.

All together, it aims to provide a completely free, open and secure alternative to the popular Viber app for mobiles.  Daniel Pocock, Lumicall project founder, will look at questions like why he chose to start with the Sipdroid code base, why he uses SIP, what level of security is really achievable on a mobile device and what kind of community effort is necessary to make this initiative successful.

This talk will present the basic algorithm, the metadata compression scheme, and the scheme for collecting both stacks of a race. I'd also like to talk about the relationship between this and "traditional" h-b implementations since both schemes have advantages and disadvantages.

Helgrind, one of the Valgrind tools, provides data race detection using a pure happens-before algorithm. Unlike many happens-before implementations, Helgrind does not detect races by creating address-indexed bitmaps and checking them at inter-thread synchronisation points. Instead, Helgrind maintains, for each byte in the address space, two vector timestamps that specify the constraints for future race-free reads and writes to that location. This presents major difficulties in storing so much information, but also makes it possible to provide exact backtraces for both accesses in a race.

This talk does not cover Helgrind's lock-order checking algorithm. Although also interesting, that is a different piece of functionality.

DevAssistant aims at making developers' lives easier. It can kickstart new projects, work with existing projects and prepare environment for development of upstream projects. We want DevAssistant to become a standard developer tool across all major Linux distributions. This presentation will introduce you to DevAssistant concept, will discuss DevAssistant internals and show you how to use it.

DevAssistant is a new project that aims at making developers' lives easier by automation of repetitive and time consuming tasks. It uses assistants, Yaml "recipe files", that contain information on how to create new projects, modify existing projects and how to setup environment for development of upstream projects. DevAssistant features include: * dependency installation * scaffolding source code for new projects or checking out source code from SCM * setting up environment on developer's machine DevAssistant is written in Python and it features a command line interface and gtk+ GUI.

In this talk we will present which changes and extensions to the L4Re microkernel system were required to actually ship L4Re in a commercial product. The talk will be a mix of an experience report and an overview of major features of the L4Re system.

The L4Re microkernel system, or L4Re in short, is a multi-tier system which is composed of the L4Re microkernel, the L4Re runtime environment and applications. L4Re aims at building sytems where components with different security mechanisms require strict isolation. Throughout the last two years L4Re has made the move from a mostly university-centric project into commercial systems.

Stardog is an RDF database for querying, searching, and reasoning about semantic graphs.

Semantic Graphs Are For Everybody explains the approach to query answering, reasoning, integrity constraint validation, and graph analysis of RDF encoded semantic graphs. The talk will explain how we provide these services to users by focusing relentlessly on usability and UX out of the box. The goal of the system and of this talk is to show how semantic graphs are useful for information integration and analysis problems.

The Grate project works on liberating NVIDIA's Tegra GPU user-space components by reverse-engineering the proprietary drivers. This talk will discuss where we are and what the future might bring.

This talk will present the goals and the current status of the Android version of Wine, and explain some of the technical challenges involved in running Windows applications on Android devices.

The Fluksometer is an open hardware/software platform that facilitates the visualisation and monitoring of 'utility' streams like water, gas, and electricity. The recently released v2B of the hardware comes with a Jeenode-compatible 868MHz radio interface. As such, the Fluksometer can now take on the role of an IoT hub which greatly expands the possible range of domestic applications it can enable. This talk would like to describe and demonstrate the new hardware as well as software components we are currently building that will turn this concept into reality.

A big part of REST is the idea of Hypermedia As The Engine Of Application State. Using HATEOAS brings the qualities of the web such as the robustness and scalability to your system.

In this presentation you will see how we have built a hypermedia-driven client using Angular.js. The media type we have used is HAL.

USE OTR (USable Encryption with OTR) is an organisation with a simple goal: improving security, usability and encryption of IM software. This talk will outline our organization, the ecosystem of Off The Record Messaging (OTR) and how to start loving end-to-end encryption.

We are an organisation that works on security, encryption and usability of open source instant messengers (IM).

One key aspect is to have developers, resources and funds available to maintain OTR software over time and thus making them sustainable, up-to-date and secure. While we have already started collaborating with the LEAP project, we want to extend our network and reach out to more people. By developing safer, usable encryption instant messaging tools we believe that it directly supports freedom of speech and expression worldwide.

Following this, we will explain what "Off The Record Messaging" is, the current state of the ecosystem around it. We want to raise awareness about the importance of using end-to-end encryption and bring the open source community together to help with this endeavour!

RubyMotion is a commercial implementation of the Ruby language for iOS and OS X development. RubyMotion makes intensive use of LLVM in order to statically compile Ruby. In this session we will focus on how RubyMotion uses LLVM also a bit of history with the MacRuby project (which uses LLVM as a JIT).

RubyMotion is a commercial implementation of the Ruby language for iOS and OS X development. The RubyMotion toolchain lets Ruby developers write full-fledged native applications for iPhone, iPad and the Mac. RubyMotion apps are statically compiled into optimized machine code.

RubyMotion makes intensive use of LLVM in order to statically compile Ruby and target various architectures. In this session we will focus on how RubyMotion uses LLVM, the challenges that we had to solve in order to compile Ruby, some of the various codegen optimizations we implemented and how we integrate with profiling/debugging tools. We will also cover the mistakes we learned from the MacRuby project, which uses LLVM a bit differently.

(This presentation will only focus on the internals of RubyMotion. We will not cover Ruby, RubyMotion or iOS/OS X development.)

In-vehicle media systems are going to be increasingly connected with other devices and media sources, that much seems certain. This could just mean integrating services like Spotify into the system or it could mean delegating actual media handling to personal devices and using the vehicle media system as just a dumb output device... but it could also mean car entertainment systems that use DLNA to interoperate with other media devices to give users all the media they want on whatever device they want.

This talk provides an overview of what DLNA can be used for in a car environment; it also tries to define what actually makes sense in that context. Rygel and dLeyna (as deployed in Tizen IVI) are used to show a practical example of this. The relevant features and requirements of Rygel and dLeyna are explained. More importantly, there will be discussion on what is required when integrating these stacks with different media players, media engines, media storages, and content security systems.

https://wiki.gnome.org/action/show/Projects/Rygel https://01.org/dleyna/

I will discuss new ideas and application domains of our Open Source IEEE 802.11a/g/p OFDM transceiver for GNU Radio. The transceiver is implemented completely in software without the need for changing the firmware of the FPGA.

For that reason, the structure and mode of operation of the transceiver is easy to understand and it is straightforward to extend. In our opinion, an SDR based WiFi transceiver has several interesting applications, one of them being its use for research in Vehicular Ad Hoc Networks (VANETs). In this field, the applications for an SDR implementation range from investigation of security and privacy issues, through simulative performance evaluation of receive algorithms, to experiments in field tests. In the talk, we discuss the possibilities and limitations of the SDR platform, as well as our current state of the art. We will highlight what is already possible, present results of our performance studies, and also show where improvements, hopefully with the help of people from the Open Source community, would be desirable.

PicoTCP: the reference TCP/IP stack for IoT

PicoTCP is a fully featured TCP/IP stack designed for embedded devices and released under the terms of GNU GPL. Our purpose is to propose it as the reference TCP/IP stack for IoT, especially due to its high portability and modularity.

This talk will explain the architecture of the stack, the way we have been developing it and the many features we support. Moreover, we will briefly show how easy it is to port the stack to a complete new architecture in no time.

After the presentation, as a test scenario, we would like to show a demo illustrating how it is possible to transport MIDI flows over WiFi with a PIC24 based board using ZMTP protocol.

Developing in enterprise is different to develop alone at home for fun. You need to have a mature stack with a tool chain that covers debugging, unit testing, software architecture, design patterns, etc. Nowadays, the Javascript community is mature enough to propose a stack that matches all aspects of the enterprise world perfectly.