FOSDEM welcome and opening talk.

Welcome to FOSDEM 2016!

systemd is a system and service manager for Linux and is at the core of most of today's big distributions. In this presentation I'd like to explain where systemd stands in 2016, and where we want to take it.

Please join me if you are interested in the Linux platform from a developer, user, administrator PoV.

It is fairly well known to the early adopters , that the devops movement would never have happened if it weren’t for a number of open source enthousiast and contributors to share their code, pains, problems , solutions and expierences at different conferences before devopsdays.

Yet today , there still is a large gap between the developers of different distros and the people that deploy and use them, the ops ..

everywhere you look you will find gaps between the developer and the users.

This talk will be about closing these gaps. It will be about helping out eachother to make Open Source solve even more Business needs. By adopting devops principles

Yet today , there still is a large gap between the developers of different distros and the people that deploy and use them, the ops ..

everywhere you look you will find gaps between the developer and the users.

This talk will be about closing these gaps. It will be about helping out eachother to make Open Source solve even more Business needs. By adopting devops principles

Free Java 2016 Introduction - Saturday

PJSIP is a free and open source multimedia communication library written in C language implementing standard based protocols such as SIP, SDP, RTP, STUN, TURN, and ICE. It combines signaling protocol (SIP) with rich multimedia framework and NAT traversal functionality into high level API that is portable and suitable for almost any type of systems ranging from desktops, embedded systems, to mobile handsets.

Please note that this talk replaces one entitled "10 days, 500k users: how we built a realtime mobile social network in Africa" that was due to have been given by Simon Tennant, who has sent his apologies but is now unable to attend as he has fallen ill. We wish him a speedy recovery.

A few warm words...

...to open the devroom.

In the talk we will present a method how to confine your IT infrastructure (at any scale) against the requirements of Payment Card Industry (PCI) Data Security Standard (DSS).

The topics covered within the talk include: * PCI DSS introduction, * language specifications used for automated assessment of security compliance, * details of PCI DSS benchmark implementation in the SCAP Security Guide, * demonstration of manual assessment of single computer using open-source tools from the OpenSCAP ecosystem, * performing corrective operations (remedial action), * presentation of open-source solution to install PCI DSS compliant system from the scratch, * large scale open-source solutions combining systems management with security compliance

In the talk we will present a method how to confine your IT infrastructure (at any scale) against the requirements of Payment Card Industry (PCI) Data Security Standard (DSS).

Starting with brief PCI DSS introduction, we will proceed to consult commonly used language specifications (XCCDF, OVAL) used for automated assessment of security compliance of a computer infrastructure. Having the basic blocks defined, we will present the details of implementation of PCI-DSS security benchmark in the SCAP Security Guide project. Subsequently we will use this benchmark definition in order to demonstrate a manual assessment of a single computer using the open-source tools from the OpenSCAP ecosystem. Being familiar with the basic toolset we will depict how these tools can be used to perform corrective operations (remedial action) in order the system to reach the PCI-DSS requirements / compliance. Later we will present motivation behind ability to install PCI-DSS compliant system right from the scratch, and also introduce a tool to help us with this effort.

Finally we will conclude with detailing how the presented approach for computer system(s)'s assessment can be used at large(r) scale introducing open-source solutions, combining systems management with security compliance. We will illustrate their application to establish a PCI-DSS compliant infrastructure, and also briefly document steps to be taken, when compliance against different security guidance / baseline would be desired. At the end we will sketch where the development in the area of security compliance might be heading in the future.

Introduction to the GNU Guile and GNU Guix projects

Introduction to the GNU Guile and GNU Guix projects

Python has quite a lot of very nice functionality hidden in plain sight. This talk will try to uncover some of them, explain how they work, when it makes sense to use them an giving practical code examples.

Python has quite a lot of very nice functionality hidden in plain sight. This talk will try to uncover some of them, explain how they work, when it makes sense to use them an giving practical code examples. The topics treated are: - Dicts - Lists - And/or usage - Default parameters - Unpacking - Exceptions - try/except/else/finally

For many years MIPS processors have been involved in the embedded market, particularly in areas related to networks and storage. With the success of the mobile market, and the great evolution of the world linked to the "makers", other architectures (such as ARM), they have reached very large levels of diffusion. Meanwhile, the mips architecture has evolved, introducing innovations and improvements to adapt to both the processor market from performance, both to the world of microcontrollers. The future of MIPS is a new family divided into several generations evolving. During the presentation, after a brief and simplified introduction to architecture, will be shown the technologies available at the time and what will be the future developments. In the presentation will also show some reference platforms (ex. Imagination Creator CI20), and how to work to integrate and port on these platforms. Application examples with yocto and buildroot, to switch to a full distribution (Debian). Finally it will also present a perspective on the use of MIPS in embedded designs.

Mips, the other side of the embedded Linux met MIPS architecture

For many years MIPS processors have been involved in the embedded market, particularly in areas related to networks and storage. With the success of the mobile market, and the great evolution of the world linked to the "makers", other architectures (such as ARM), they have reached very large levels of diffusion.

Meanwhile, the MIPS architecture has evolved, introducing innovations and improvements to adapt to both the processor market from performance, both to the world of microcontrollers. The future of MIPS is a new family divided into several generations evolving.

During the presentation, after a brief and simplified introduction to architecture, will be shown the technologies available at the time and what will be the future developments.

In the presentation will also show some reference platforms (ex. Imagination Creator CI20), and how to work to integrate and port on these platforms. Application examples with yocto and buildroot, to switch to a full distribution (Debian). Finally it will also present a perspective on the use of MIPS in embedded designs.

Once upon a time, an operating system scheduler was TheOne_ entity in charge of deciding what "activity" would run on a physical processor. Furthermore, such "activity" would pretty much all the time be an application (or system) program. Well, guess what: these days, things are more complicated! Applications and physical processors have moved away from each other, as one or more layers have been put in between them. In fact, in a typical virtualization/cloud scenario, we have a hypervisor, providing the abstraction of virtual processors, and it is onto them that applications run. And here we are: running an application inside a virtual machine requires a virtual processor to be scheduled on a physical processor --at the host level-- and the application itself to be scheduler on the virtual processor --at the guest level. So, two schedulers (at least!).

But how do these two schedulers interact right now? How should they interact ideally? Should they be closely related, completely independent, or something in the middle? Are they better be based on the same algorithm? Or do different layers have different enough needs to require highly specific solutions?

This talk will go through the above (and more) questions, trying to outline pros and cons of a few approaches. That will happen both in a "theoretical" and practical sense. The latter meaning that we will be looking at some real scheduling traces (at both host and guest level), and at numbers from different benchmarks. The main focus, especially of the 'case study' part, will be on the Xen's scheduler(s) (i.e., on the interactions between Xen's and Linux's schedulers) but we will have a look at a few KVM data points as well.

One Scheduler to rule them all. One Scheduler to find them, One Scheduler to bring them all and...

Recently, while investigating, and trying to improve, performance of the Xen hypervisor, a number of non previously obvious interactions between host and guest level scheduling have been identified. This means, in case of Xen, interactions between the Xen's scheduler (at the host/hypervisor layer) and the Linux scheduler (at the guest layer).

Traces have been collected and benchmarks have been run, in order to figure out the exact nature of those interactions, and even more in order to amend or, at least, mitigate, the ones that were causing badly performing behaviours. Similar situations when other hypervisors (namely, KVM) were in use, have been inspected too, out of interest and for reference.

The results of such investigation, both in terms of generic thoughts and reasoning, and in terms of traces and numbers is what the talk will cover.

The library eCoAP is intended to be this easiest way of writing simple CoAP service. Its design enforced expressivity, efficiency and memory usage. As such, this library is the library of choice for people designing small systems offering CoAP accesses.

• short presentation
• short examples
• advantages
• drawbacks

Feel free to arrive early, to start the day with some informal discussions while the set-up of the DevRoom is finished.

The Italian defense organization - Army, Navy and Air Force - is migrating to LibreOffice and ODF, in one single large project coordinated by a mixed group of soldiers and community members. The odd relationship between an extremely structured organization and a loosely tied community, which have learned to trust each other and to work together to reach a single objective.

The Italian defense organization - Army, Navy and Air Force - is migrating 150,000 desktops from various flavors of MS Office to LibreOffice and ODF, in one single large project coordinated by a mixed group of soldiers and community members. The first shift will migrate 55,000 desktops in 2016, while the remaining 95,000 will be migrated during the following four years. So far, the combined project team has trained a group of 32 trainers and support professionals, and the trainers have done the first short training to Rome based division IT managers. The presentation will tell about the odd relationship between an extremely structured organization and a loosely tied community, which have learned to trust each other and to work together to reach a single objective. Also, it will explain the technical activity for the integration of LibreOffice with the three different document management systems.

Kaltura makes use of Mediainfo to detect source video attributes and FFMPEG in order to optimise the transcoding of source videos into multiple flavours to be consumed by different devices.

The session will review how this is achieved using the KDL [Kaltura Decision Layer].

The session will cover the following sub-topics:

• Video file detection and transcoding

  • Transcoding Profiles and Flavor Params
  • Mediainfo
  • FFmpeg
  • A walk through the KDL [Kaltura Decision Layer] code

• Playback

  • Playback methods [Progressive HTTP, HDS, HLS, DASH]
  • What is a playback manifest?
  • An end to end walk through of the playback process

• Live demo

FOSS TCAD/EDA tools for semiconductor device modeling Numerical Cogenda TCAD MOSFET Device Simulations Semiconductor Device Simulation Using DEVSIM Device Level Parameter Extraction Schematic entry and circuit simulation with Qucs Qucs modeling and simulation of analog/RF devices and circuits Simulations of Digital IC Blocks Hybrid TCAD Circuit Simulations Standardized Data Exchange For Device Modeling Tools

A brief look into the history and vision behind a web-based open-source operating system.

Back in the Summer of 2011, two engineers at Mozilla had just finished making a complete rendering engine for PDF files using JavaScript and HTML5 (https://mozilla.github.io/pdf.js/). Emboldened by this success, the question they kept asking themselves was "is there anything JavaScript can't do?" Somehow, the idea of building an entire phone operating in JavaScript got in their heads. So they decided to investigate how technically possible it was, and thus Boot to Gecko (later Firefox OS) was born.

In this talk, I want to shed some light on the how Firefox OS came about, and how it developed over the last 5 years at Mozilla. This is not really a talk about the UX, or content design, or the marketing of Firefox OS, but rather about Mozilla's journey through the mobile OS landscape. I also hope to leave some time at the end to answer any questions people may have.

How can we grow the MySQL Community? It has always been hard to find qualified MySQL Developers and Database Administrators and there is still a great shortage. The NoSQL world has bright shinny 'toys' and MySQL is now in a 'young adult stage'. With containerization and verbalization there is more demand for the MySQL skills but that does not seem to be growing the community at the same pace. So how do we promote our community to attract more people, how do we promote the knowledge of MySQL skills to hiring managers, is there a way to mentor new people as does the PHP Community, and how do we provide support for each other. Please come to provide your ideas so we can get more of us.

How can we grow the MySQL Community? It has always been hard to find qualified MySQL Developers and Database Administrators and there is still a great shortage. The NoSQL world has bright shinny 'toys' and MySQL is now in a 'young adult stage' which keeps us from the 'new and flashy' crowd. With containerization and verbalization there is more demand for the MySQL skills but that does not seem to be growing the community at the same pace. The MySQL Certification exams are much more difficult and maybe more relevant to the true job functions but it seems to have slipped in prestige. AWS, Aurora, other other similar technologies are MySQL-like but how do we leverage those professionals into the MySQL Community? So how do we promote our community to attract more people, how do we promote the knowledge of MySQL skills to hiring managers, is there a way to mentor new people as does the PHP Community, and how do we provide support for each other. I honestly think it is time we try to coalesce strategies to help build and promote the MySQL community. Please come to provide your ideas so we can get more of us.

Introduction to LXD, the container lightervisor by its project leader.

LXD is a container management tool built on top of LXC and offering a REST API to manage and interact with multiple container hosts over the network.

This talk will go over the main features of LXD, a pretty thorough demonstration of its abilities, a run through the work currently being done and end with questions.

LXD is a project which began a bit over a year ago, by the same team who built LXC.

It's building on top of the very stable LXC library and adds a whole network layer to it through a simple and clean REST API.

It's user experience was rethought from the ground up, favoring security and reliability, using every single kernel security feature available to provide a safe, yet extremely fast environment. Reliability is achieved through extended error handling and the use of container images in place of locally built container templates.

LXD focuses on infrastructure containers, that is, containers running a full Linux distribution exactly as you would in a virtual machine. It doesn't know about nor care about application containers (docker, rocket, ...). Those technologies are great to manage micro-services and are a good way to distribute software, as such they make a lot of sense, inside a LXD container.

More information on the LXD project can be found at: https://linuxcontainers.org/lxd The code may be found at: https://github.com/lxc/lxd And a fully feature, interactive demo of its capabilities here: https://linuxcontainers.org/lxd/try-it

A review of the past year in the life of the OpenJDK Community, and a look at what's ahead.

The seL4 microkernel is the world's first OS kernel that is formally verified to contain no bugs. After several years of development as a proprietary technology, the kernel was eventually released as open source in summer 2014. This prompted me to explore the use of seL4 as base platform for the Genode OS framework. The talk will introduce seL4, explain the interplay of Genode with the kernel, and present the current state of development.

The Genode OS framework is a tool kit for building component-based operating systems. It combines microkernel technology, capability-based security, and virtualization with a unique component architecture that allows it to scale from static embedded systems to highly dynamic general-purpose workloads.

Since its inception in 2008, Genode was designated as user land for the L4 family of microkernels. In that spirit, it supports most members of the family including L4ka::Pistachio, L4/Fiasco, OKL4, NOVA, and Fiasco.OC. Each of those kernels has different pros and cons. Genode enables software developers to target all of them at once, and allows system integrators to pick the kernel that fits best.

The seL4 kernel is the latest and supposedly greatest member of the L4 family. What sets it apart from all the others is the premise, under which it was designed and developed: The formal verification of the kernel's correctness while achieving high performance. Similarly to NOVA and Fiasco.OC, it employs capability-based security as the fundamental mechanism for guarding the access to kernel objects. But in contrast to the existing kernels, it also attacks the fundamental problem of managing kernel memory from the user land - a problem that used to be conveniently ignored by all prior L4 kernels.

After several years of development behind the closed doors of NICTA, seL4 was finally set free under the GPL license in 2014. From Genode's perspective, this sounded almost too good to be true: An open-source microkernel that is formally verified to be correct, well documented, backed by an enthusiastic community, and equipped with all the basic functionality required by Genode!

It goes without saying that - as a Genode developer - I was thrilled to bring both projects together. After conducting a series of experiments exercising the kernel interface, I started adapting Genode to seL4 as a personal side project. Even though the seL4 kernel and the Genode user land should intuitively fit perfectly together on paper, the devil lies in the details. In the talk, I'd like to share those details, the challenges that had to be overcome, and the solutions I came up with. It provides insights into both the seL4 kernel interface and Genode's underpinnings, and gives a glimpse of the future direction.

Several sources of data consist of events representing relationships between entities, like user interactions in a social network, clicks on pages linking to each other, purchases of products on web stores, etc. These streams of real-time data can be represented as dynamic graphs, where each event adds or updates an edge in the graph.

Processing dynamic graphs is a challenging task that requires sophisticated state management, snapshotting mechanisms, and incremental graph algorithms. Luckily, several graph computations, like graph statistics, aggregates, and graph sketches, as well as more complex algorithms like connected components and bipartiteness detection, can be computed in a single-pass fashion. Single-pass algorithms process each edge once and do not need to store or access the complete graph state.

In this talk we will give an overview of the Apache Flink streaming API and show how we can leverage it for building graph streaming applications. We will show how to implement single-pass graph aggregations and single-pass graph algorithms, like connected components and bipartiteness detection. Finally, we will give a preview of a work-in-progress graph streaming API, which we are building on top of Flink.

Open Document Format has been tested at so-called Plugfests over the years. At these plugfests compatibility between ODF implementations is tested. This started out as a manual process with a wiki and USB sticks. ODFAutoTests have increased the amount of testing that can be done at a plugfest. More testing could be plugfests lasted longer. To make that possible, a web server is being developed.

The web server builds on the ideas of OfficeShots and ODFAutoTests. The current version is implemented in Haskell with the Yesod framework. The talk will go into the workflow of testing and how it can be implemented in a web page.

This presentation will be a guided tour of porting Guix and its package collection to a new platform, with the specifics of GNU/Hurd. We will discuss the current status of the project. Next we will raise the problems we faced and how we solved them. Finally we wiil present a road map for porting GuixSD, the standalone system distribution on GNU/Hurd.

This presentation will be a guided tour of porting Guix and its package collection to a new platform, with the specifics of GNU/Hurd. We will discuss the current status of the project. Next we will raise the problems we faced and how we solved them. Finally we wiil present a road map for porting GuixSD, the standalone system distribution on GNU/Hurd.

In this session, Steven Goodwin will practically demonstrate the various "moving parts" necessary to build a WebRTC application, by creating one live on stage.

Although the marketing hype suggests you can build a 'Skype in a browser' in an afternoon, it doesn't really tell you how. Or where the problems will occur. This talk will cover both the client and server-side code necessary. Targeted at developers of all levels who are unfamiliar with webRTC, it will provide a better understand of how WebRTC applications work under the hood, what the API provides, and serve as a guide as to what is (and what is not) possible for the developers to deliver.

With the newly added JSON support in MySQL, you can combine the flexibility of NoSQL with the strength of a relational database. In this session, Morgan will explain the new JSON datatype, and the new set of functions for handling JSON documents, available storage and indexing options. In addition, he will present benchmarks showing how much one can expect from the MySQL server in different use case scenarios.

With the newly added JSON support in MySQL, you can combine the flexibility of NoSQL with the strength of a relational database. In this session, Morgan will explain the new JSON datatype, and the new set of functions for handling JSON documents, available storage and indexing options. In addition, he will present benchmarks showing how much one can expect from the MySQL server in different use case scenarios.

Mozilla recently announced WebExtensions, a new add-on development API largely based on the extensions API for Chrome and Opera. In this session we'll discuss the motivation behind the future move to WebExtensions and show the general structure and code of a WebExtension.

Mozilla recently announced WebExtensions, a new add-on development API largely based on the extensions API for Chrome and Opera. In this session we'll discuss the motivation behind the future move to WebExtensions and show the general structure and code of a WebExtension.

The Global Public Inclusive Infrastructure (GPII) is an open-source infrastructure developed by Cloud4all and several other R&D projects that aims to support automatically adaptive user interfaces and thus enable "Design for One".

Design for All strives to create user interfaces "for human diversity, social inclusion and equality" (EIDD Stockholm Declaration, 2004). In spite of its name, the goal of Design for All is not to create a single solution for everybody ("one size fits all"). However, most software comes with settings and options that need to be tweaked by the user, and most users never change a program's settings. Many users are unaware of the available settings, they are afraid of breaking something, etc. What is needed is software that adapts to the user's needs and preferences, so users don't need to worry about where to find the settings. Ideally, the user's needs and preferences should also be "translatable" to other systems, e.g. from a desktop PC to mobile devices, websites and ticket vending machines. The Global Public Inclusive Infrastructure (GPII) is an open-source infrastructure developed by Cloud4all and several other R&D projects that aims to support automatically adaptive user interfaces and thus enable "Design for One". However, even this approach assumes that interfaces have accessibility features (though not necessarily enabled by default), so it does not make Design for All redundant.

This talk is intended as an introduction to a more technical talk about GPII in the same devroom.

Cockpit is the new system admin UI for Linux. It's a default part of Fedora, and available in other distros as well.

Cockpit turns a Linux server into something discoverable and usable. All while being zero-footprint: It goes away when not in use.

In this talk we'll how how Cockpit works: It's an actual linux user session that you drive through your browser, running with user privileges, and accesses to the native system APIs and tools. Cockpit reacts instantly to server changes made by other tools.

We'll also show you how to contribute, and talk about what you'll see next in Cockpit.

(Please note that the presenter of this talk changed after the booklet went to press.)

AsteroidOS is a free and open-source smartwatch platform based on OpenEmbedded, libhybris, BlueZ5 and Qt5. The OS currently offers a basic user experience on the LG G Watch. This technical talk will briefly introduce the philosophical background of the project and more deeply its architecture's details in order to attract developers, porters and curious.

Smartwatches can be superfluous gadget making one more intrusion into our privacy or formidable platforms for developers. This is why it is important to have an open platform for this type of devices. AsteroidOS seeks to address this problem.

This talk will successively be focused on how to boot an Android Wear watch, on how to gain hardware acceleration on that kind of hardware, on how Qt5 and OpenEmbedded are used and on the future of AsteroidOS.

AsteroidOS uses similar technological choices as those of projects like SailfishOS, NemoMobile, Mer, WebOS-Ports or Ubuntu Touch but adapted to the needs of smartwatches. The architecture of those project will briefly be compared during the presentation.

We will provide an overview of the advanced topics presented in the Legal and Policy Issues Devroom

Introduction to the Legal and Policy Issues Devroom

Gnucap, the GNU circuit analysis package, is a flexible mixed-signal circuit simulator with significant technical advantages over SPICE derivatives. This talk is about development and usability status of the core and several derived works of the last years.

Gnucap consists of a core library and plugins. The core library is primarily the work of Albert Davis, who has started his project well over 30 years ago. This talk will outline the meaning of an experimental fork, Gnucap-uf, which has evolved from work at the university of Frankfurt. Gnucap-uf mostly adds research specific features, relying on ad-hoc changes to the kernel and interfaces. For example, state space inspection and ageing simulation functionality has been added without sticking to the intended data structures. Beyond that, several extensions written for this fork still (could (easily made to)) work with the original project. This talk will address three of them.

"gnucap-adms" is a verilog model compiler based on admsXml, which has been written with focus and intent on simple academic proof-of-concept examples. After some extra work and cleanup, it is now possible to (partly) translate bsim6 compact models into functional plugins.

"gnucap-geda" (formerly lang_gschem) was meant to turn Gnucap into the intended schematic translation and exchange platform. Specifically, as a GSoC project (2012), a language plugin targetting the gEDA schematic format has been implemented, demonstrating the conversion from schematics first into the internal data format and second into another language such as verilog.

"gnucap-qucs" is a project that implements a Gnucap based replacement for "qucsator", the simulator used by QUCS, a graphical user frontend to circuit simulation. Qucsator implements several component models and commands, which must be provided by extensions for Gnucap. Some of these do now exist. The corresponding language plugin enables the processing of qucsator input files.

Security is on everyone's mind these days, software will always have bugs that can be exploited. In virtualisation, those bugs are more often found in device emulators and the hypervisor itself includes a few of those, for performance reason. How can we mitigate the severity of those bugs?

This presentation will talk about limiting the impact of bugs in device emulators by deprivileging their execution. Right now, they run with the same privileged as the rest of the Xen hypervisor, but we will show what we can do to execute these emulations in a deprivileged context.

This solution comes with a performance cost. We will learn the cost compared to the original and try to apply this to emulators that are either not used often or that takes much more time to execute than to switch to a deprivileged context.

Making many devices discover and interact with each other is the big challenge ahead of the IoT. Companies are already eager to make their solutions be the common denominator of all your devices, usually based on their central cloud. Alidron project aims at finding a different approach based on features seen in industrial control systems, with a distributed twist while keeping a fuzzy limit between edge computing and cloud computing.

Control systems are software usually seen running large industrial, infrastructure and research equipment. They boast certain capabilities like aggregating and distributing data from and to hardware, generating alarms and events based on these data, maintaining the configuration between the data-channels and the real hardware sources, archiving these data, offering integrated diagnostic tools, and providing a consistent view of the monitored processes in a user interface.

Today's solution for control systems are not a close match for the Internet of Things. They are based on a master-slave pattern where devices can't take much decision by cooperating with other devices. All interactions between devices have to happen within a predefined framework of features the provider thought of, which are usually lagging behind the fast-moving IT world by many years, if not decades...

Alidron is an attempt at mixing concepts from control systems with ubiquitous computing and becomes an Ambient Intelligence platform. Its first demonstration is using it for smart home behaviours. Firstly, it links devices with other devices as well as with control programs. Some of these control programs are actually used for learning home users habits and learn how to become proactive for them. It allows these nodes to run indifferently on devices, on a local computer or in a cloud provider.

Digital hardware design, or “HDL programming,” is growing in popularity with the widespread availability of FPGA platforms. Yet, the ecosystem around it needs some work. Tooling, the availability of code, licensing and a scattered community make it hard to get started. In this talk, we'll look at the situation today, and where things are going. As newcomer you'll leave the talk with all you need to know to start an FPGA design. And as experienced developer you will get an update on what's going on around you. Because digital hardware design doesn't need to be hard.

Build your own processor! Improve your graphics chip! Sounds far fetched? Actually, it does not need to be.

In the free software world, we have come to enjoy an ecosystem of excellent code to build on, production-quality libraries, reliable tools, and a healthy and helpful community. Software development has become available to the masses.

Getting started in digital hardware design, a.k.a. “writing code that describes how a chip works”, is not as easy yet. Trouble already starts with the question “What do you want to do with your design?” Producing a chip still is rather expensive, and looking at the product of long nights of work in slow-motion simulations it not terribly rewarding. Here FPGAs, “reprogrammable chips,” have come to rescue. With eval boards starting at under $100 and Intel incorporating FPGAs into their processors, hardware access has become easier. With this problem out of the way, we can now focus on the ecosystem of free and open source digital hardware design.

Join me for a look at code, tools, licensing, and the community. What's already there? What can we take from the software world? And where is all this going? All to answer the ultimate question: when will we be able to create our own processor?

With JDK 9 development underway in the OpenJDK Community, and based on our experiences with open source projects testing against JDK 9 Early Access builds in the Quality Outreach effort, it seems like a good idea to compile the accumulated wisdom to make it easier for new projects to start testing against JDK 9. In this session, you'll learn how to prepare your code for some of the upcoming changes in JDK 9 and how to join the OpenJDK crowd testing fun with your own open source project to help make JDK 9 better.

Contract testing provides a means for developers to provide tests to implementers of Java SPI and API frameworks to ensure that the expected functionality is correctly implemented. It is an open source junit extension that tests implementations of java interfaces. This talk will cover why and how to execute tests.

Contract testing provides a means for developers to provide tests to implementers of SPI and API frameworks to ensure that the expected functionality is implemented. Junit-contracts is a Junit runner and associated annotations that allows developers to develop test for correct implementation of an interface that are then reused by any implementation of the interface. The junit-contract tests suite does this automatically discovers the tests to be run and executes them. This presentation is an overview of the design principles behind the junit-contracts tool, how to develop tests that it can run, and how they can make development easier for project developers, QA teams and the system integrator while reducing support requests and problem tickets.

This presentation is intended for development teams that provide an SPI or user extensible API and who wish to provide tests that ensure the correct implementation of interfaces. This talk should also be of interest to QA testers that need to validate that a number of implementations of a single interface are correct and for systems integrators to wish to ensure that implementations of SPI/APIs in glue code function correctly.

From building video walls to multi-room audio playback, many use cases require synchronised multimedia processing between several independent devices.

In this talk Luis will introduce how data flow handling synchronization in the GStreamer multimedia framework works, show the features provided to make it easy to develop such applications and explain demo code snippets using these.

From building video walls to multi-room audio playback, many use cases require synchronised multimedia processing between several independent devices.

In this talk Luis will introduce how data flow handling synchronization in the GStreamer multimedia framework works, show the features provided to make it easy to develop such applications and explain demo code snippets using these.

The aim of this talk is to share with the audience the interesting clock handling technology in GStreamer and how one pipeline's clock can slave from an other pipeline's clock, even in an other device over the network. This opens a wide range of very interesting use cases, the one used as a demo during the talk would be playing music that follows you around your home.

Learn how to make games with nothing but the standard library and a console. Because you don't need a huge framework or complex tools to have fun!

To explain the basics of game making, two different examples will be shown. Nothing but a default installation of python is necessary to make games, so we can just focus on the different concepts and elements. Except for a minimal amount of automagic, most of the code will be very basic, no advanced knowledge is necessary.

Having spent more than the last decade being the main point of contact for distributions shipping MySQL, then MariaDB Server, it's clear that working with distributions have many challenges. Licensing changes (when MySQL moved the client libraries from LGPL to GPL with a FOSS Exception), ABI changes, speed (or lack thereof) of distribution releases/freezes, supporting the software throughout the lifespan of the distribution, specific bugs due to platforms, and a lot more will be discussed in this talk. Let's not forget the politics. How do we decide "tiers" of importance for distributions? As a bonus, there will be a focus on how much effort it took to "replace" MySQL with MariaDB.

Benefits: if you're making a distribution, this is the point of view of the upstream package makers. Why are distribution statistics important to us? Do we monitor your bugs system or do you have a better escalation to us? How do we test to make sure things are going well before release. This and more will be spoken about.

As an upstream project (package), we love nothing more than being available everywhere. But time and energy goes into making this is so as there are quirks in every distribution.

MidPoint is an comprehensive open source Identity Management system. It can handle even a very complex enterprise IDM scenarios and it can replace commercial IDM systems. This talk will introduce the basic architecture of Identity and Access Management (IAM) solution with midPoint as the IDM component.

Identity and Access Management (IAM) solutions are almost always composed of several components that needs to be integrated. The Identity Management (IDM) component is the crucial integrating part. However the open source IDM solutions were very simplistic in the past and only commercial IDM solutions were available to handle complex IDM deployments. But now there is a viable open source solution. MidPoint is an open source IDM system that can completely replace commercial products. It has all that an IDM system should have: synchronization, RBAC, attribute mappings, workflow, reporting, governance, etc. It is the most comprehensive open source IDM solution available.

This talk with start by introducing basic components of Identity and Access Management (IAM) solution. It will describe the crucial role of an IDM system in the solution. We will argue that no enterprise security project can ever be complete without and IDM and we will show why. We will also describe how midPoint can be a perfect solution.

Welcome to the Ada Developer Room at FOSDEM 2016, 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.

Physical servers are so 2010 and so are VMs. Containers? Well, you're already living the dream, but there's something just around the corner and you surely have already heard about it: AWS Lambda, webtask.io, and StackHut are the new new kids on the block and in this talk we will see what they bring to the table for you as an appop and also what the implications are for your devops and sys admins.

Physical servers are so 2010 and so are VMs. Containers? Well, you're already living the dream, but there's something just around the corner and you surely have already heard about it: AWS Lambda, webtask.io, and StackHut are the new new kids on the block and in this talk we will see what they bring to the table for you as an appop and also what the implications are for your devops and sys admins. We will have a look at the current landscape, discuss challenges and the opportunities in this space as well as have a closer look at the offerings. In addition, concrete use cases and application areas, such as IoT will be discussed. A short demo will walk you through the basics and show what the pros and cons are.

An 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!

The tragic terrorist attacks in Paris have fueled, even more than before, a strong campaign against widespread adoption of encryption tools, even if it soon became clear that the terrorists hadn't used any. While in USA plans for the adoption of compulsory backdoors, in order to circumvent encryption, have been apparently abandoned, many European States seem to perceive encryption software and devices as one of the worst evils. Which is the role of FOSS and FOSS developers in this scenario? How can we enhance communication privacy, without breaking any regulations?

FOSS has always played a key role in enabling secure communications and systems: from encrypting filesystems to allowing anonymous browsing, free and open source tools are fundamental. In the aftermath of the tragic terrorist attacks in Paris, a strong campaign against widespread adoption of encryption tools has gained momentum, even if it soon became clear that the terrorists hadn't used any anonymization technique. While in USA plans for the adoption of compulsory backdoors, in order to circumvent encryption, have been apparently abandoned, many European States seem to perceive encryption software and devices as one of the worst evils. How can FOSS and FOSS developers play a part in this scenario? Will it still be possible to develop and use encryption, to enable communication privacy, or will developers and users run the risk of incurring in some liability? The talk will examine the current European Legal framework, in order to assess which part can FOSS have in the ever-shifting balance between security and privacy, involving the audience with some case studies and personal experiences.

The help is a vital component of high quality applications. Help files need continual maintenance when the application is improved further. LibreOffice provides the "HelpAuthoring" extension, to make contributions to the help easier for help authors. It serves both developers and dedicated users. This talk shows how to use the tool and provides a glance at its operating principles.

Wisp is a language for Guile which represents Scheme sexp structure transparently using indentation. It makes Scheme look easy for non-Schemers without losing any of its power.

»ArneBab's alternate sexp syntax is best I've seen; pythonesque, hides parens but keeps power« — Christopher Webber

I plan to present its syntax, show some of the elegant solutions with Guile using wisp to make them easy to read, and describe how wisp was cleanly integrated in Guile.

Wisp is specified in SRFI-119.

Janus is an open source WebRTC Gateway developed by Meetecho conceived to be a general purpose one. As such, it doesn't provide any functionality per se other than implementing the means to set up a WebRTC media communication with a browser, exchanging JSON messages with it, and relaying RTP/RTCP and messages between browsers and the server-side application logic they're attached to.

Any specific feature/application is provided by server side plugins, that browsers can then contact via the gateway to take advantage of the functionality they provide. Example of such plugins can be implementations of applications like echo tests, conference bridges, media recorders, SIP gateways and the like. A few examples describing how these plugins can be used as "bricks" to build a more comprehensive and complex application will be provided. Some references to existing usages of Janus and third-party imlementations will be presented too, as well as some notes on future plans and next steps.

The first stable version of MySQL 5.7 was released in October with a large number of new features and improvements, such as JSON support, new optimizer hints, functional indexes, a query rewriting framework, a new optimizer cost model, new GIS functions, a number of InnoDB improvements, Group Replication, Fabric, performance schema extensions, SYS schema, Workbench, and much more!

This talk covers all that and more. We won't go into the details of every feature, but we'll get a quick overview of what's new and how all the individual pieces fit together.

The first stable version of MySQL 5.7 was released in October with a large number of new features and improvements, such as JSON support, new optimizer hints, functional indexes, a query rewriting framework, a new optimizer cost model, new GIS functions, a number of InnoDB improvements, Group Replication, Fabric, performance schema extensions, SYS schema, Workbench, and much more!

This talk covers all that and more. We won't go into the details of every feature, but we'll get a quick overview of what's new and how all the individual pieces fit together.

A short presentation and update about VLC, libVLC and the VideoLAN community.

A short presentation and update about VLC, libVLC and the VideoLAN community.

One of the key objection raised on IoT is security. Adding security to IoT present two challenges faces: - the delivery of a secured but flexible small embedded OS - the availability of a development environment which enable non security programmer experts to create a safe product.

IoT is often perceived as a glorified embedded challenge. While this is technically partially correct, the market vision of delivering >50 Billion devices by 2020 is not compatible with the current small poll of available embedded developers. The presentation will present solutions which are available in the Open Source and can be used to create an IoT OS and framework which can provide a reasonable security and privacy protection while opening the domain to non expert programmers.

We will address the following issues : - secured boot on standard Open Source HW. - Code and data Integrity - Secured upgrade - Middleware and Application containment. - Developer environment.

Camille has been actively promoting Open Source, Open Standards and interoperability for more than ten years, notably as a member of the AFUL, where he's been a member of the board since 2007. Leveraging his significant experience in helping corporations defining Open Source strategies and conformance policies, he's co-leading the Open Source governance activity at inno³. He's also particularly interested in the tooling enabling a better Open Source management.

Most dependency managers integrate a licensing dimension to their packages and their contributors are generally very receptive to best practices in the domain, like following the SPDX standard and its evolutions. The importance of the legal dimension of these tools is underlined by the evolution of the services that are built on top of them: services like versioneye and librairies.io had their primary focus on technical aspects (like detecting not up to date dependencies), but now also includes features related to licensing like licence whitelisting or licence compatibility. This short talk will present a summary of the maturity of the different package managers licencing-wise, some examples of concrete issues of implementing best practices, and tools that already exist or that are still lacking to allow developpers to take advantage of easily-available licensing information.

How can Guix and Guile participate in increasing network freedom? Discussions include leveraging Guix to make server deployment and maintenance a better experience, as well as ideas in how Guile could provide leadership in web development and federation. Perspectives from the needs of GNU MediaGoblin for deployability will be presented to the audience, as well as contextualizing Guix deployment in terms of "UserOps" (in parallel with / in contrast to DevOps).

The Global Public Inclusive Infrastructure aims to deliver a cross-platform solution that can improve significantly the way we actually interact with computers and other devices such as smartphones, ATMs or any general public access devices. During this session, we will describe the state of the art of the GPII, what's in progress and future works.

As the outcome of the recently finished EU funded project Cloud4all, many pieces of the GPII have been built in order to demonstrate the concept of the GPII and how it would work in the future. As a result, we've integrated the GPII on both GNU/Linux and MS Windows platforms, and we have also created an infrastructure to perform a full layered adaptation of such platforms and in order to drastically decrease the time that people with disabilities can spend on configuring the system when they start using a new computer or interacting with a public device. During this session we will focus on describing: * How the GPII runs on different and supported platforms * How the GPII makes the auto-personalization of the system at different levels * How third-party ATs, software such as web browsers, cloud-based ATs or even web sites can make use of the auto-personalization features of the GPII * Current limitations * Ongoing work

This talk presents Qucs (Quite Universal Circuit Simulator) features, the current status of development and the project roadmap.

Qucs is an integrated circuit simulator. The graphical user interface (GUI) is used for schematic capture and visualization of simulation results. It can simulate the large-signal, small-signal and noise behavior of the circuit. The software aims to support all kinds of circuit simulation types such as DC, AC, transient, S-parameter, noise analysis, harmonic balance analysis. Digital simulation and circuit optimization are integrated into the GUI and powered by other open-source tools (Icarus-Verilog, freeHDL, ASCO). Besides the library of components it also includes tools for the design of active and passive filters, transmission lines, attenuators and matching circuits. Interfaces for Matlab/Octave and Python are also available.

The talk will provide an overview of the features and available tools along with a selection of examples. It will present the latest developments including: ongoing migration towards the latest Qt framework; new features related to the “turn-key” Verilog-A (ADMS) model compiler as well as support for other simulation engines (Ngspice, Xyce).

With some real world examples, I'll explain the interest of async pattern and give some clues when it's interesting to use.

Moreover, I'll demonstrate why the inclusion of async/await+AsyncIO in the core of Python is a smart move, from a technical and political point of view. Finally, I'll present some libraries in the AsyncIO toolbox.

One of the not so well-known tools of the HotSpot VM is its Whitebox-Testing API. Introduced in Java 7 it has been significantly improved and extended in Java 8 and 9. It can be used to query or change HotSpot internals which are not otherwise exposed to Java-land. While its features make it an indispensable tool for writing good HotSpot regression tests, it can also be used for experiments or for the mere fun of peeking into the VM.

This talk will give an overview of the Whitebox-Testing API, it will show you how to build and use it and finally it will explain how the API can be easily extend to fit your own needs.

Docker has brought an ease of use without comparison with VMs typically to build native upstream distribution packages. Where before it was needed to launch a complete environment, copy the sources into it, invoke the build tools to create the packages and then copy them back to the host, Docker has made all these steps much easier and straight forward, allowing for more rapid package production and automation.

This presentation will show a detailed use case for building packages for both Mageia and Fedora with their respective bm or koji tools encapsulated in Docker containers. It should help any upstream packager adopt a similar approach to make his packaging task a breathe.

It's easy to spot if a word is missing in a spellcheck dictionary. But it's much more complex to find out if a dictionary contains words that are actually wrong. We'll see how to clean up a dictionary in a safe way and the benefits this brings.

There is a new, Blink-compatible API in Firefox called WebExtensions. Extension code written for Chrome, Opera, or, possibly in the future, Microsoft Edge will run in Firefox with few changes as a WebExtension. It will be shown how to use this API to develop addons for Firefox OS.

For some time we’ve heard from add-on developers that our APIs could be better documented and easier to use. In addition, we’ve noticed that many Firefox add-on developers also maintain a Chrome, Safari, or Opera extension with similar functionality. We would like add-on development to be more like Web development: the same code should run in multiple browsers according to behavior set by standards, with comprehensive documentation available from multiple vendors.

To this end, we are implementing a new, Blink-compatible API in Firefox called WebExtensions. Extension code written for Chrome, Opera, or, possibly in the future, Microsoft Edge will run in Firefox with few changes as a WebExtension.

The QEMU and KVM developers' efforts towards a high-performance block layer started back in 2012, and are now seeing the light. In this presentation I will lead the audience through this multi-year journey.

I will explain the structure of the QEMU block layer, why it has traditionally preferred cooperative multitasking (coroutines) to threads, and how to reconcile this design with the high level of parallelism required by modern PCIe storage devices.

The vast majority of devices in IoT space are constrained devices. A lot recent developments and standard initiatives have addressed connectivity solutions for constrained devices by introducing protocols such as CoAP and MQTT. With connectivity in place, the next challenge is how these devices can make use of the existing Web services. This talk introduces the web service interface (WSI) layer in IoTivity framework to address this challenge. A demo on how IoT devices can seamlessly access cloud Services with the helps of WSI in IoTivity stack will be given.

Web services have been one of the latest technological changes that are revolutionizing the world of business and our everyday lives. With the huge expanding of Things in the IoT world, the vision of accessing web services is not only for smart device any more. The existences of trillions of constraied devices brings great challenges and possibly opportunities of seamless interoperability with existing web services.

In this talk we will discuss the technical challenges from various aspects. A general review of existing solutions in industry and proposals/initiatives in research and standard will be given. To introduce the appoach used in IoTivity, we first give a detailed background introduction on IoTivity framework. Based on this we will discuss that with some of the most compelling applications in the IoT space involve rich and differentiated interactions between people and devices, a interface layer is required to provide features to help web service developers to introduce and tailor their service to the IoT context. This talk is supported by a demo on how IoT devices can seamlessly access cloud Services with the helps of web service interface layer in IoTivity stack.

RISC-V is the most recent attempt (originally from UC Berkeley) to design a brand new instruction set architecture based on the reduced instruction set computing (RISC) principles. One of its goals is to be completely open and free (both as in free beer and as in free speech) for designers, users and manufacturers. HelenOS is an open source operating system designed and implemented from scratch based on the microkernel multiserver design principles. One of its goals is to provide excellent target platform portability and it currently supports 8 different hardware platforms.

Both projects are still in the process of maturing: While the unprivileged (user space) instruction set architecture of RISC-V has been declared stable in 2014, the privileged instruction set architecture is still in a stage of draft and is allowed to change in the future. Likewise, many major design features and building blocks of HelenOS are already in place, but no official commitment to ABI or API stability has been made yet.

This talk introduces both projects, presents the initial lessons learned from porting HelenOS to RISC-V and evaluates the portability of HelenOS on yet another porting effort.

Several new kernel features are under development which will improve the container experience. We will go over these features, explain how they benefit containers, and demonstrate each.

Several new kernel features are under development which, if successful will improve the container experience. These include cgroup namespaces, loopback namespaces, fuse mounts in unprivileged containers, targeted file capabilities, stacked apparmor profiles, and udev message namespacing. These would allow containers without a "true" root user to create and mount filesystems, use file capabilities to reduce the root privilege used in the container, better virtualize cgroup usage, protect containers from their own workloads using apparmor, and better delegate hotplugged devices to containers.

In this talk we'll go over these features and their current status (at the time of FOSDEM).

GNU Guile has a wonderful and welcoming community, but could things be better? The recent website redesign is a great start... can we expand on that initiative? What can we learn from related projects in this space?

GNU Guile has a wonderful and welcoming community, but could things be better? The recent website redesign is a great start... can we expand on that initiative? What can we learn from related projects in this space?

We want to present the openCypher project, whose purpose is to make Cypher available to everyone – every data store, every tooling provider, every application developer. openCypher is a continual work in progress. Over the next few months, we will move more and more of the language artifacts over to GitHub to make it available for everyone.

openCypher is an open source project that delivers four key artifacts released under a permissive license: (i) the Cypher reference documentation, (ii) a Technology compatibility kit (TCK), (iii) Reference implementation (a fully functional implementation of key parts of the stack needed to support Cypher inside a data platform or tool) and (iv) the Cypher language specification.

We are also seeking to make the process of specifying and evolving the Cypher query language as open as possible, and are actively seeking comments and suggestions on how to improve the Cypher query language.

The purpose of this talk is to provide more details regarding the above-mentioned aspects.

We want to present the openCypher project, whose purpose is to make Cypher available to everyone – every data store, every tooling provider, every application developer. openCypher is a continual work in progress. Over the next few months, we will move more and more of the language artifacts over to GitHub to make it available for everyone.

openCypher is an open source project that delivers four key artifacts released under a permissive license: (i) the Cypher reference documentation, (ii) a Technology compatibility kit (TCK), (iii) Reference implementation (a fully functional implementation of key parts of the stack needed to support Cypher inside a data platform or tool) and (iv) the Cypher language specification.

We are also seeking to make the process of specifying and evolving the Cypher query language as open as possible, and are actively seeking comments and suggestions on how to improve the Cypher query language.

The purpose of this talk is to provide more details regarding the above-mentioned aspects.

You, of course, write open-source software. They didn’t. And for the sake of your mobile users, you both need to be friends. Enter Frida, the diplomat (she’s really only a library, but don’t tell anyone). She has coaxing superpowers that allow you to expose the innards of binary-only software, be it other libraries, operating systems, or other OS processes you must deal with. You can program Frida to infiltrate closed-source software, and expose their internals into abstractions you can use for testing the interoperability of your software. Want to lift some of their logic into your mock? Or replace a few functions in their binary code with your mocks? Hopefully, you want to do that using high-level languages such as JavaScript and/or Python, because those are the ones Frida likes the most.

In this talk, we use Frida, the scriptable, dynamic instrumentation toolkit, to expose internal functionality from binary-only software. By exposing internal functions and data structures, tightly integrating software often becomes easier to test at fine granularity. What previously had to be larger integration tests dependent upon several running subsystems, may, with a little effort, become isolated test fixtures that are easier to reason about. We show you unfortunate souls who have to deal with this level of interoperability how to program Frida to identify and expose functions in remote processes, and how to combine these exposed functions into small test fixtures in a unit-testing style.

Based on Migen, MiSoC is a library of cores and a system-on-chip integration system to build gateware for various applications. MiSoC is lightweight (runs on FPGA devices as small as Spartan-6 LX9 with 32-bit RISC CPU and SDRAM), portable (demonstrated on Xilinx, Altera and Lattice devices) and high performance (e.g. contains the fastest open source DDR3 solution we are aware of). Designing and integrating cores is facilitated by Python and Migen features. Current MiSoC applications include LTE base stations, video processing (Numato Opsis) and experiment control system (ARTIQ).

This talk introduces the functional package manager GNU Guix and the underlying concept of functional package management to a general audience.

This talk introduces the functional package manager GNU Guix to a general audience.

All users should be able to use all applications, despite any kind of condition (blindness, colorblindness, deafness, ...). Without accessibility, software excludes the people who can not use them. I will introduce accessibility, the accessibility stack, and the good practices to keep in mind while designing applications so they get accessible by design.

All users should be able to use all applications, despite any kind of condition (blindness, colorblindness, deafness, ...). Without accessibility, software excludes the people who can not use them. Fixing the accessibility of an application after having developped it can be quite costly, while designing applications with accessibility in mind from the start does not cost much.

Actually, for a fair part, accessibility in design boils down to well-known good practice, such as structuring the application logically without any particular rendering in mind.

I will introduce to accessibility, the accessibility stack, and the good practices to keep in mind while designing applications so they get accessible by design.

SUMO (short for Support Mozilla) is a volunteer-powered, international support platform with millions of visitors speaking multiple languages, each month. Learn from us how to build a fully localizable wiki-like site (yes, we're forkable on GitHub!) and help us help others with your coding (and not only) skills.

This talk will present the Kitsune platform, and the work that's done on it and with it, by our developers and volunteers. Apart from presenting the scale and background of Kitsune, the presentation will also offer options of getting involved in our project for the greater good of the helpful web around the world.

In this talk I will present the first 4 projects of the "Make with Ada" blog post series: a solenoid engine, an Apollo lunar lander simulator, a software synthesizer framework, and a formally proven smartwatch app. I will also explain the motivation behind this series, where we want to go, and the feedback we've got from it.

FPGA Manager & devicetree overlays - Making FPGAs first class citizens in the upstream Linux Kernel

Static System on Chip (SoC) configurations commonly found in today's embedded systems can be easily described by devicetree files. These files provide the kernel with the necessary information about hardware devices, their connections, clocks, resets and other properties that could be either runtime probed, or would be provided by the BIOS on normal PC systems.

FPGAs have been present in embedded systems for a long time. Their reconfigurability allows for in-the-field upgrades to large parts of a system's functionality. For this kind of reconfigurability it is sufficient to reload the FPGA image once at boot, and to present the peripherals in the programmable logic parts to the Linux Kernel in the same way as any other hardware.

With FPGA based SoCs such as Altera's SocFPGA and Xilinx Zynq this model of reconfiguration poses its challenges, as runtime reconfiguration (and even partial reconfiguration) may cause parts of the fabric-based logic to temporarily (or permanently!) disappear. In that case presenting the FPGA based logic to the kernel might lead to issues as the corresponding device drivers don't get unloaded properly when the corresponding logic goes away.

Vendor trees (that contain modifications to the Linux Kernel, that have not been upstreamed) provide userland applications with a capability to reload the FPGA image. In this case a hybrid system with in kernel drivers and userland applications is quickly forced into using ugly hacks to make it all work together.

FPGA manager is a vendor-neutral framework currently under development (will be in 4.4), that allows reloading FPGA images in a safe, clean and intuitive manner, while nicely integrating with the Linux Kernel's driver model.

To model the dependencies of FPGA based IP in processor based SoC's the SimpleFPGA bus was developed. It allows to specify dependency topologies to reconfigure SoC busses at runtime, while dealing with issues such as runtime clock control, resets, as well as loading the correct (partial) bitstreams through FPGA Manager.

Originally developed to support the BeagleBone Black's capes that require runtime pinctrl, devicetree overlays can be used to change the Linux Kernel's representation of the devicetree at runtime. Recently merged into upstream devicetree overlays provide a very natural and clean way to describe modifications to the devicetree, while keeping the whole system in a coherent state.

This talk will give a brief intro to devicetree, the problems related to runtime reconfiguration and then describe the SimpleFPGA bus and FPGA Manager frameworks. Some simple examples using devicetree overlays will be given that will demonstrate why the three elements make for such a compelling combination.

This talk will explore how the next generation video player can be expanded to create interactions with the content and the viewers. Most video player experiences are based on the original TV set metaphor and provide a passive viewing experience. We will review examples based on the Kaltura Player infrastructure and ideas on how video playback can change to engage users and create interactive experiences.

What are the features of Haiku's package management system? How does its design impact packaging of ported software? We'll answer this and list some good and bad practices that affect the portability of software to Haiku.

Inspired by the BeOS, a desktop operating system ahead of its time but where software were still packaged as zip files or click-to-install files distributed manually, Haiku has grown a dozen years this way. But things change, and Haiku made the big leap into modern software packaging, with a new infrastructure that could probably inspire even mainstream GNU/Linux distributions.

Haiku's package management is a radical change from its historical roots, affecting even native software despite existing APIs like find_directory(). Ported software are also impacted by those changes, but also benefit from HaikuPorts which streamlines packaging for Haiku developers and changed their lives literally.

Not unlike other packaging frameworks like Guix, Haiku's package management required changes to the filesystem layout inherited from BeOS, including making parts read-only. It brings many features but also complicates porting sometimes, which will be discussed.

In near future, objects will dialog together through internet or near field hadhock networks. What's about your privacy data? Recent use cases in the automotive industry have shown how much it can cost to under estimate hacker's skills. In our current work for designing a security architecture for cars and connected objects, we used smack LSM and cynara service for isolating applications and services from the baseline system. This model is base on the idea that application should not be trusted, it guarantees that no data can be stolen by application and it supports native, html5 and cloud models.

The market sells more and more connected objects. These objects have a computing unit and most of it are able to connect to some kind of cloud. This is a fact.

There are motivations and interests in developing open frameworks for creation of applications for such objects.

When developing the system and its application framework, master pieces of knowledges and feedbacks are expected from telephone industry, where iOS and Androïd showed the high potential of markets for applications. But a car is not a phone!

Do you lend or resell your mobilephone? Is your mobilephone potentially lethal?

For each of the previous questions the answer is yes when the word "telephone" is replaced by the word "automobile". But you could find other devices: camera, watch, television, refrigerator, ... However, automobile seems to be one of the most complex connected object. All of this brings in the front of the scene many usages that are reasking and enforcing our practicals of security and privacy.

This talk presents the security considerations linked to my work for AGL (Automotive Grade Linux). AGL is a project of the Linux foundation. AGL project released its first specification in spring 2015.

It will explain how isolation of applications and isolation of in-deep parts of the system are required to ensure privacy and safety.

Legal decisions related to an open source project serve multiple purposes. One of the constituencies of these legal policies is the community of contributors to the project. Unfortunately, the effect of legal policy decisions by a primary copyright holder can have unanticipated negative effects on this constituency.

Some legal decisions which have an effect on the contributor community are: * License choice * Contributor licensing agreements * Determining origin of contributions and "clearing" them * Trademark usage policy

Dave Neary is a community manager with a long history of participating in and organising open source community projects, and he will walk you through some of the ways in which decisions in these areas have actively harmed project growth in the past, and may suggest some alternatives which accomplish similar goals without the same side-effects.

Legal decisions related to an open source project serve multiple purposes. Some of those purposes are:

• The protection of contributors from legal risks
• The protection of users from legal risks associated with using the software
• Protection of the good name and brand of the project through trademark
• Enablement of business models for primary contributors

But one of the constituencies of an open source project,namely the community of contributors to the project, is often forgotten, or the effect of other legal decisions on them are underestimated.

Some legal decisions which can have an adverse effect on the contributor community are: * License choice * Contributor licensing agreements * Determining origin of contributions and "clearing" them * Trademark usage policy

Dave Neary is a community manager with a long history of participating in and organising open source community projects, and he will walk you through some of the ways in which decisions in these areas have actively harmed project growth in the past, and may suggest some alternatives which accomplish similar goals without the same side-effects.

In this session we will focus on gathering, processing & visualising data from various IoT and human sources, reviewing the various technologies available to unify the data whilst providing a deep dive into the Matrix.org decentralised data ecosystem.

After an introduction to the problem space and available solutions, we will focus on introducing Matrix's architecture and its open source, Apache-licensed reference client and server implementations.

This session will show how to actually build an entirely open and dentralised IoT platform using open source software. Together we will start from scratch, check-out the code and first get a Matrix webclient running. We will use this as a dashboard to collate and visualise data from a variety of connected devices and services, federated together in an open ecosystem via Matrix. We will then add services on top to further aggregate, process and route the data.

We will also discuss exactly how you could extend the platform for advanced features and for your own specific needs. We will look at some examples (wearable computing, drone control/telemetry/video, robotics) that we and the community have implemented during various hackathons and projects - and show how IoT data may be bridged into non-IoT communication platforms such as IRC or Slack via Matrix.

Real-time charging, opensource

Proposed Session Description

 Internet Telephony has evolved over the years from simple office PBX to clustered voice services. CGRateS project was born out of today’s market demand for performance and scalability when it comes to Real-Time Charging. 
In this talk Dan will briefly introduce CGRateS’s architectural concepts and advantages of using it for distributed charging, exemplifying use cases for account bundles, fraud detection with automatic mitigation or advanced real-time call statistics with actions triggered on threshold hits.
CGRateS is a battle-tested, real-time Charging Engine which supports 4 different charging modes: Prepaid, Pseudo-prepaid, Postpaid and Rated

During my last CPython sprint, I started to contribute to the CPython code, and I wanted to understand the beast.

In this case, there is only one solution, trace the code from the beginning. From the command line to the interpreter, we will take part to an adventure.

During my last CPython sprint, I started to contribute to the CPython code, and I wanted to understand the beast.

In this case, there is only one solution, trace the code from the beginning. From the command line to the interpreter, we will take part to an adventure.

Overview of the structure of the Project and the directories. From the Py_Main function, to the interpreter the used technics for the Lexer, Parser and the generation of the AST and of course of the Byte Code. we will see some byte codes with the dis module How does VM works, it’s a stack machine. the Interpreter and its main loop of the Virtual Machine. The idea behind is just to show how CPython works for a new contributor to CPython

Enterprise environment means a lot of integration to work together. Single sign-on, VPNs, access controls, boring user experience, multiple third-party applications which may not be playing well with each other. FreeIPA is a project providing an integrated and secure setup of complete free software stack that makes up a typical enterprise environment.

As remote work spreads wider, 'an enterprise' becomes a home environment as well: more applications are moved to cloud hosting, both on premises and at third parties' clouds, and more people have to balance their home and work identities and data at the same time. This talk will explain our work together with GNOME community to produce a desktop environment friendly to enterprise and how it makes our home environments more secure without compromising on usability.

In GNU Radio, we often find ourselves going to the FM broadcast stations as a first introduction to radio, software radio, and signal processing. FM broadcast is nearly ubiquitous and has a narrow enough bandwidth that very inexpensive hardware all over the world can work with it. It also has an interesting enough structure that allows us to go from simple to more complicated GNU Radio applications for studying all sorts of ways in which we can process it as a signal.

FM broadcasting is present almost anywhere in the world, and its structure makes it an interesting challenge and good learning exercise for developing GNU Radio applications. Likewise, almost any software radio RF front end is capable of processing FM: from the very cheap RTL-SDR dongles to the more expensive USRPs. In this talk, I will introduce FM from its historical roots and walk through why it is a technologically important development as I build more complicated GNU Radio applications to explore the FM waveform. As a broadcast medium, FM has also played an important political, social, and cultural role in the last century. Aside from the technical development of how to process FM signals, I will use this lecture as an introduction to regulatory agencies and band planning. Part of this will involve the development, problems, and importance of FM pirate radio. The lecture will involve a demonstration of embedded GNU Radio applications that will showcase the FM capture effect by imitating a (very) low power radio station.

MySQL Group Replication is a recent MySQL plugin that brings together group communication techniques and database replication, providing both a high availability and a multi-master update everywhere replication solution.

High availability is achieved through redundancy, by consistently replicating data throughout a set of MySQL servers. Multi-master update everywhere is based on row-level conflict detection on the fact that the plugin leverages distributed coordination among servers to deploy consistent conflict handling. Thus the system behaves as a replicated state machine. To have all this working together, there is an underlying work of a well-known paradigm in distributed computing: Group Communication and Distributed Consensus - that is becoming quite hot in the software industry nowadays, along with with top-notch software architecture.

Come and learn what it is, where to get it and how to use it. Get to know how to install, configure and deploy it in your existing infrastructure.

MySQL Group Replication is a recent MySQL plugin that brings together group communication techniques and database replication, providing both a high availability and a multi-master update everywhere replication solution.

High availability is achieved through redundancy, by consistently replicating data throughout a set of MySQL servers. Multi-master update everywhere is based on row-level conflict detection on the fact that the plugin leverages distributed coordination among servers to deploy consistent conflict handling. Thus the system behaves as a replicated state machine. To have all this working together, there is an underlying work of a well-known paradigm in distributed computing: Group Communication and Distributed Consensus - that is becoming quite hot in the software industry nowadays, along with with top-notch software architecture.

Come and learn what it is, where to get it and how to use it. Get to know how to install, configure and deploy it in your existing infrastructure.

The Difference between Theory and Practice is greater in practice then it is in theory. We are on the brink of our first official release of Shenandoah. It took two weeks to write up the design and over two years to implement it. This talk will discuss the differences between what we initially proposed and what we now have working. An honest look at compromises, wrong turns, and innovations. We will finish the talk with the theory of what comes next: A high level design for NUMA aware GC, a sketch of a plan for truly pauseless GC, a brief consideration of reference counting...

This talk describes the problems we face with the current toolbar implementation, ideas how to improve it and the ongoing work in this area.

Update: This talk will be given by Katarina Behrens as I won't be able to attend FOSDEM this year.

Xen on x86 platforms offers two kinds of virtual machines: PV and HVM. PV is the oldest kind of guest, doesn't need any emulation, but requires extensive modifications to the guest operating system kernel. HVM is a newer kind of guest, which exploits hardware virtualization extensions, and offers an emulated PC-like environment. Linux typically runs on Xen as a PV guest but can also run as an HVM guest very efficiently. Windows runs as an HVM guest only.

QEMU is a critical component in Xen deployments because is in charge of emulating most devices for HVM guests, including IDE disks and PCI network cards. In fact in the Xen community QEMU is often called the "device model". QEMU's emulated interfaces are conveniently available for the guest to use. At the same time of course they are also exposed to malicious guests, which are inevitably going to try to find vulnerabilities in those interfaces, to take control over the system.

Therefore securing QEMU is critical. QEMU should be protected from guest attacks, not just in best case scenarios, where deployments use advanced and complex security hardening techniques, such as stubdoms or SELinux, but in all cases, for all users.

This presentation will show the defense in depth mechanisms which the Xen Project is putting in place to secure the execution of QEMU in Dom0 by default. The talk will explain the reasons behind the design choices and how they compare against other hypervisors and other deployment scenarios. Users will learn the trade-offs of the different solutions and will learn how to discern secure from insecure configurations.

Docker is not just for deployment. As a developer, there are many ways Docker can make you more productive, regardless of how your app gets deployed.

In this session, you will learn practical strategies for using Docker, including how to:

• Run unit tests locally in multiple environments with almost no overhead.
• Make your integration tests easy for anyone to run by distributing them in a Docker image.
• Simulate advanced network topologies, especially for a service-oriented architecture.
• Make a Docker image in 5 minutes or less that produces builds from a consistent environment.
• Isolate database state changes in your test suite by using a pool of disposable containers.

Sharp.Xmpp

Sharp.Xmpp is a multiplatform, Windows and Android, .NET XMPP client library. It supports IM functionality & a variety of XMPP extensions, is simple and is extensively tested against both Android and Windows platforms. It is a fork of the currently frozen excellent S22.Xmpp project. In the first part of the presentation will discuss Sharp.Xmpp capabilities, protocols supported, examples for usage and extension. The second part will focus for using Sharp.Xmpp for mobile development for Android, lessons and experiences learned. Necessary hooks, alarms, network connection events, ping time, and battery consumption information will be provided, from a Sharp.Xmpp perspective and mobile development using Mono. Sharp.Xmpp since its release has gained some uptake, since, to the best of my knowledge, it one of the very few available modern C# open source XMPP libraries currently available. Participation in the conference will help expand uptake, and its contributor base.

Features

The library fully implements the XMPP Core and XMPP IM specifications and thus provides the basic XMPP instant messaging (IM) and presence functionality. In addition, Sharp.Xmpp offers support for most of the optional protocol extensions. More specifically, the following features are supported:

-SASL Authentication (PLAIN, DIGEST-MD5, and SCRAM-SHA-1) -User Avatars -SOCKS5 and In-Band File-Transfer -In-Band Registration -User Mood -User Tune -User Activity -Simplified Blocking

It is a fork, of the excellent but now inactive S22.Xmpp library and features:

-API designed to be very easy to use -Well documented with lots of example code -Very easy to add extensions -Open source MIT License, suitable for a wide range of business models.

The library is extensively tested for a multi platform Android/Windows project, user base has been increased, as well as patch contributors. It offers C# a versatile way to start building XMPP applications. Sharp.Xmpp for Android In the second part experiences from using Sharp.Xmpp in a mobile Android application will be provided. Android platform features will be discussed and code snippets such as:

-setting Android alarms for keep TCP connections alive, -network connection events detection, -server pings before timeouts

These will be discussed from a C# Xamarin perspective. Using techniques described connection stability and battery consumption are excellent.

Added to LibreOffice 4.0 for the first time, sidebar became a popular part of its UI. providing access to more and more functionality with every release. This talk (or better, tutorial) will enable new as well as experienced developer to dive deep into anatomy (structure) as well as physiology (function) of sidebar and its decks and panels. At the end, you should be able to create your first panel, either in LibreOffice core or as an extension.

Blender (www.blender.org) is a versatile 3D studio that, among other things, contains a handy rendering preview which renders lights and shadows in the 3D editor view. We will be exploring this feature to create a virtual studio to play with lighting ideas.

Blender (www.blender.org) is a versatile 3D studio that, among other things, contains a handy rendering preview which renders lights and shadows in the 3D editor view. We will be exploring this feature to create a virtual studio to play with lighting ideas.

A brief introduction on security in the IoT devices. This talk will talk from the perspective of how security is defined in OIC (Open Interconnect Consortium) and implemented in IoTivity.

With the rapid growth and interest in IoT, there is a growing need to address the security vulnerabilities that currently exist. This talk provides an overview of the challenges faced and how they can be addressed in terms of secure communication, key exchanged and how device to device communication can be controlled. The audience will also learn about the solution developed in IoTivity so far and some of the ongoing work in this area.

game-data-packager is a tool that automate the creation of .deb or .rpm packages for local consumption from commercial games assets.

Handling of non-free non-redistributable data like shareware games assets are commonly handled by fragile shell scripts that involve wget, unzip, md5sum provided by the different distributions.

game-data-packager provides a way to share these unofficial packaging efforts in a central location; only a tiny part of this tool is distro-specific and is handled in a nice OO-model.

GDP has builtin support for the Steam & GOG.com online sellers and will also apply the patches needed by your games.

GDP would also fill a common need of upstream game engines providers that either have to document all the needed files: (like http://wiki.scummvm.org/index.php/Datafiles) ... or have to provide their own installer.

Camelot is a Python library for building business applications on top of Qt. This talk will explain the building blocks it contains and how they fit together, with a focus on the new functions. It will demonstrate how to use Python to develop both desktop and mobile applications using QML.

Camelot is a Python library for building business applications on top of Qt. This talk will explain the building blocks it contains and how they fit together, with a focus on the new functions. It will demonstrate how to use Python to develop both desktop and mobile applications using QML.

GNU Guix and GuixSD provide a transactional package manager and purely declarative GNU/Linux distribution. Under the hood, Guix builds upon a unified set of Guile Scheme programming interfaces, making it "The Emacs of Distros." This talk will give an overview of those APIs and how they can be used.

The talk will cover things like store remote procedure calls (RPCs), multi-tier programming with G-expressions, the monadic store API, and more.

MariaDB 10.1 has a new tool for diagnosing optimizer issues: ANALYZE for statements.

The talk with start with an introduction to ANALYZE [FORMAT=JSON] command. Then, I'll show how one can use ANALYZE to quickly pinpoint various kinds of optimizer issues. The talk is only 20 minutes long, but we will be able to solve multiple query optimization problems because ANALYZE command allows one to do it so quickly!

MariaDB 10.1 has a new tool for diagnosing optimizer issues: ANALYZE for statements.

The talk with start with an introduction to ANALYZE [FORMAT=JSON] command. Then, I'll show how one can use ANALYZE to quickly pinpoint various kinds of optimizer issues. The talk is only 20 minutes long, but we will be able to solve multiple query optimization problems because ANALYZE command allows one to do it so quickly!

The devroom is not supposed to schedule a lunch break. Let's do something different then.

Let's do some microkernel-related networking while eating in the devroom!

We will bring a fully open source FPGA toolchain for the RaspberryPi FPGA board we developed.

The board can be seen in action at https://twitter.com/oe1cxw/status/673484838037516288

We do have a working open source toolchain for Lattice FPGAs. We can generate a bitstream on a RaspberryPi or on any other CPU.

We will make available some of our Lattice FPGA boards for the RaspberryPi to qualified FPGA hackers and demonstrate also cool demos with lots of LEDs.

Currently Clifford did port a 32bit Risc-V CPU to the FPGA, and can run software on the Risc-V CPU. It is also planned to port micropython to the board.

Yosys (Yosys Open Synthesis Suite) is an Open Source Verilog synthesis and verification tool.

Project IceStorm aims at reverse engineering and documenting the bit-stream format of Lattice iCE40 FPGAs and providing simple tools for analyzing and creating bit-stream files, including a tool that converts iCE40 bit-stream files into behavioral Verilog. Currently the bitstream format for iCE40 HX1K and HX8K is fully documented and supported by the tools.

Arachne-PNR is an Open Source place&route tool for iCE40 FPGAs based on the databases provided by Project IceStorm. It converts BLIF files into an ASCII file format that can be turned into a bit-stream by IceStorm tools.

This three projects together implement a complete open source tool-chain for iCE40 FPGAs. It is available now and it is feature complete (with the exception of timing analysis, which is work in progress).

In this presentation, Solène Buet will detail how W3C TTML subtitles can be used with MPEG DASH streaming, and how it was tested with the EBU-TT-D standard (TTML-based).

Solène implemented EBU-TT-D subtitling with the dash.js reference player.

Solène will explain what TTML-based subtitles are, and how they can be retrieved from a MPEG DASH stream for rendering in the player.

The presentation will cover the process followed by a TTML-based subtitle: from its recovering, to its parsing and its displaying.

You will get an insight in the very hot topic of subtitling through streaming technologies.

PostgreSQL database has various features aimed at the Internet of Things Use Case. Talk will discuss these features and other features on the PostgreSQL dev roadmap.

Start by looking at the characteristics of the Internet of Things Use Case, and showing how each of these things is helped by various features in PostgreSQL.Discusses features developed as a result of specific EU funding to support this area of work. Question & Answer session about future requirements and in-progress R&D.

When is distribution not distribution?

‘Distribution’ triggers copyleft obligations, and accurate interpretation of copyleft licences is dependent on an accurate determination of 'distribution'. In the course of other research, we developed a model containing a spectrum of software use-cases illustrating what activities may result in distribution, as defined in law, and which therefore trigger the copyleft conditions in FOSS licences. This talk explains the model, and the use-cases, and explores, from a European Copyright Law perspective, when software can be considered to have been distributed, and what the consequences are for copyleft in each case, with reference to the GPL, AGPL and other FOSS licences.

In researching a wide range of contracts which Swedish schools require their students to enter into to enable the students to access school computing facilities (including the provision of FOSS), it became clear that a key issue, in the case of each contract, was whether the specific item of FOSS had been ‘distributed’ to the students in question, so as to trigger the copyleft condition of the relevant FOSS licence.

Accordingly, we hypothesised a spectrum of cases covering scenarios when distribution definitely occurs (A provides B with a copy of GIMP on a CD), to when it definitely doesn’t occur (A looks over B's shoulder while B is using GIMP and following A's instructions). In between are less clear cases such as: A lends B a phone containing FOSS code; A leases a phone containing FOSS code to B for a year; A allows B to access GIMP on a virtual machine under A’s control; A hands over administrative access to the VM to B. It is not obvious, legally, whether in each of these cases ‘distribution’ has occurred.

The EU case of Peek & Cloppenburg KG v Cassina SpA suggests that distribution can only take place in connection with the transfer of a physical object: a literal reading would suggest that downloading software and transferring it between VMs does not amount to distribution. This case was discussed in UsedSoft GmbH v Oracle International Corp, which approves Cassina, but also considers digital transfer.

It has been argued (under German law) that software is distributed when its functionality is accessed on a SaaS basis (thus making GPL not only equivalent to AGPL, but actually going somewhat further)?

This talk (25 mins) explores the spectrum of use cases, and considers which, under European copyright law, are likely to be considered as triggering copyleft provisions. It also considers whether the result is likely to differ depending on the (copyleft) licence employed, and what some of the practical implications of this analysis may be.

Many people find delegating to be one of the more difficult elements of leadership. This session will discuss barriers to delegating, how to overcome them, and how to give good feedback to others.

Delegation is important because it helps to prevent burnout, develops skills in others, and generates a culture of enthusiasm, innovation, creativity, cooperation, and openness. Delegating allows you to be more effective and productive.

In this session, we'll talk about ways to effectively delegate, common barriers and concerns, and how you can help your delegatee be successful. We'll also talk about how to give good feedback to those you delegate to.

(Please note that the title of this presentation was changed after the booklet was printed.)

Last year I presented some work I had done on the ARM microJIT to enable it on the Raspberry PI. At the end I suggested the creation of an AArch32 project to do a fully fledged ARM32 port. I am pleased to say that an OpenJDK AArch32 port has been created and we have an initial port of the Template Interpreter thanks to some excellent work by Joseph Joyce.

This talk will update on the progress of the AArch32 project and also a call for help so we can finally get the ARM32 properly supported in OpenJDK.

Bruno Latour wrote a book about philosophy (an inquiry into modes of existence). He decided that the paper book was no place for the numerous footnotes, documentation or glossary, instead giving access to all this information surrounding the book through a web application which would present itself as a reading companion. He also offered to the community of readers to submit their contributions to his inquiry by writing new documents to be added to the platform. The first version of our web application was built on PHP Yiii and MySQL on the server side. This soon proved to be a nightmare to maintain because of the ultra-relational nature of our data. We refactored it completely to use node.js and Neo4J. We went from a tree system with internal links modelized inside a relational database to a graph of paragraphs included into documents, subchapters etc. all sharing links between them. On the way, we've learned Neo4J thoroughly, from graph data modeling to cypher tricks and developped our custom cypher query graphical monitor using sigma.js in order to check our data trans-modeling consistency.

During this journey, we've stumbled upon data model questions : ordered links, sub items grouping necessity, data output constraints from Neo4J, and finally the limitations of Neo4J community edition. Finally we feel much more confortable as developers in our new system. Reasoning about our data has become much easier and, moreover, our users are also happier since the platform's performance has never been better.

Our intention is, therefore, to share our experience with the community:

- our application's data needs
- our shift from a MySQL data model to a Neo4J graph model
- our feedbacks in using a graph database and more precisely Neo4J including our custom admin tool [Agent Smith](https://github.com/Yomguithereal/agent-smith)
- a very quick description of the admin tools we built to let the researchers write or modify contents (a markdown web editor)

The research has received funding from the European Research Council under the European Union’s Seventh Framework Programme (FP7/2007-2013) / erc Grant ‘IDEAS’ 2010 n° 269567”

Authors :

Guillaume Plique A graduate student from Sciences-Po Lille and Waseda University, Guillaume Plique now offers the médialab his backend development skills as well as his profile in social sciences. He has been working since June 2013 on several projects such as IPCC mapping, AIME and develops scrapers aimed at social sciences researchers. https://github.com/Yomguithereal

Paul Girard Paul Girard is an Information Technology engineer specialized in driving collaborations between technology and non-technical domains. He graduated from the cultural industry engineering specialisation in Université de Technologie de Compiègne in 2004 where he studied the relationships between digital technologies and society and the mechanisms of collaborations. He worked in the research laboratories federation CITU (Paris 1 and Paris 8 universities) from 2005 to 2009 where he participated in research and creation projects, collaborations between artists and engineers working with interactivity, digital pictures, virtual and augmented reality. He joined the médialab laboratory at Sciences Po at its foundation during the spring of 2009, as the digital manager of this digital research laboratory dedicated to fostering the use of digital methods and tools in Social Sciences. Since then he oversees the technical direction of the many research projects as collaborations between social sciences, knowledge engineering and information design. His present research fields are digital methods for social sciences, exploratory data analysis and enhanced publication though digital story telling. https://github.com/paulgirard

Daniele Guido Daniele Guido is a visual interaction designer interested in data mining applications, text analysis and network tools. He collaborates with researchers in History and Social Science, designers and engineer to conceive and develop digital tools for the humanities. He recently joined the DIgital Humanities lab at CVCE team in Luxembourg after several years working at the Sciences-Po Medialab team in Paris, where he was engaged in the FORCCAST project (forccast.hypotheses.org) and in the AIME project (modesofexistence.org) https://github.com/danieleguido

Testing embedded systems

With the advent of IoT, this presentation makes the case for TDD and BDD in general and focuses on its use within embedded software development. Test Driven Development (TDD) and Behaviour Driven Development (BDD) are established tools in the traditional IT realm and are at the core of the XP methodology. This presentation incorporates these methodologies with the world of Embedded programming. Using TDD and BDD tools such as Unity and Cucumber, we'll explore how to develop and test software that runs on the target devices.

Using Unity, I'll show how unit tests can be run on target embedded devices as a better alternative to using simulators.

In addition, using the Cucumber gem, I will demonstrate how to use feature files in the context of working on embedded hardware projects and explain how to extend the framework using the Wire protocol to allow integration tests to run in-situ, which greatly enhances testing coverage compared to PC-based testing using emulators.

We use american-fuzzy-lop for fuzzing various file formats that LibreOffice supports. Here I demo some amusing hackery to use afl to fuzz a stream of keyboard events in order to attempt to flush out unknown or difficult to reproduce bugs.

American fuzzy lop (http://lcamtuf.coredump.cx/afl/) is a security-oriented fuzzer that employs a novel type of compile-time instrumentation and genetic algorithms to automatically discover clean, interesting test cases that trigger new internal states in the targeted binary.

Typically its used for file format fuzzing. In this case the file format is a trivially serialized sequence of keystrokes, allowing afl to be an engine to drive the LibreOffice UI to generate test cases that crash LibreOffice via user events.

Filesystem fragmentation is long standing and well known problem. Modern filesystems has effective techniques and tools to minimize fragmentation and aging effects. But filesystem aging can not be avoided completely. This is true for all filesystems: ext4,xfs,btrfs,zfs,logfs,etc. This becomes a very serious problem for container/cloud solutions because most solutions use thin-provision storage. This talk overview existing techniques, our experience and new tools we develop for OpenVZ project

XMPP is coming back, and is here to stay! Through a large collection of analysis and interviews, as a Product Owner in different organisations, we can say now that XMPP is getting out of the tunnel.

We will review where we were, where we are, and where we are headed. This answers, the why, and what? This is also a wake up call for consciousness, and product/market fit. This answers the why, and who?

You can view XMPP and Instant Messaging from different angles: * If you observe the market since the the 90s, you will see the three generations of Instant Messaging: * The first generation: ICQ and its clones * The second generation: WhatsApp and its clones * The third generation: Slack and its clones => this is just the beginning * If you use the Gartner Group's "Hype Cycle": * XMPP has passed the the "Peak of inflacted expectations", and is now in the "Trough of dillusionment" (read the "XMPP myths" thread on Hacker News) * So expect a "Slope of enlightenment" and a "Plateau of productivity". * If you consider the communities (including commercial entities): * Some have lived and died, some wake up, some just minimalistically maintain their software and infra... * There is wave of cleanup of dead things, and a wave to help the XSF

This talk explains why Dropbox considered rolling out global transaction IDs. Additionally we discuss the steps involved in deploying such a change across a large fleet, the challenges faced, open issues, and lessons learned during the migration. If you missed this talk at Oracle Openworld here's a second chance.

This talk explains why Dropbox considered rolling out global transaction IDs. Additionally we discuss the steps involved in deploying such a change across a large fleet, the challenges faced, open issues, and lessons learned during the migration. If you missed this talk at Oracle Openworld here's a second chance.

Coming up with logos can be an exhausting process sometimes. In this session we will watch a short screencast of mine which I will comment on, including some use cases of logo designs from Mozilla and other open source projects.

Coming up with logos can be an exhausting process sometimes.

Should you get paper and pencil ready or dive directly into Illustrator? Before going neck deep into your logo project, check out following thumb rules to keep in mind when working on your logo. You will be learning about basic color theory, cliches and metaphors specifically guiding you in your logo endeavours. Some of these tips can be generally applied to most logo projects, while some others might suit the needs of different logos.

In this session we will watch a short screencast of mine which I will comment on, including some use cases of logo designs from Mozilla and other open source projects.

I present my experiences of adopting the maintenance of Whitaker's Words, a Latin dictionary written in Ada by Col William Whitaker, who was deeply involved in the creation of Ada itself.

This will be the perspective of someone from outside the Ada community who found he really liked the language, and the challenges I faced learning Ada from online materials, converting the Words source code to more idiomatic (post Ada-83) forms, adopting the tooling, accessing community support, finding collaborators, making Ada play nicely with the Web, and so on.

Whitaker's Words may be one of the most widely-used pieces of Ada software, and a quick Twitter search suggests it plays a key role in helping students cheat on their Latin translation homework. As a linguist and hacker, what really interests me is the use of Ada's type system to encode Latin's grammar.

When everything is connected we can question what programming approach is most suitable. Programming interconnected systems shows similarities to programming for multiple processors. However, programming for multiple processors is a challenging task. We propose and demonstrate an easy framework based on lessons learned from programming for IoT scenarios which shows potential for programming multiple processors as well.

Approaches to program concurrently require a thorough understanding of the computer. Not all people who program possess this. However, as processors are not getting faster, everybody will need to program concurrently eventually. One of the main challenges of programming for multiple processors is the fact that it is often approached from a sequential programming perspective. When dealing with IoT it is usual to send and receive messages thus this becomes the paradigm. This paradigm is one of interacting entities passing messages rather than parsing logic sequentially. Based on these hypothesis we have researched an easy framework to program for multiple processors as well as devices connected through the network. We have tested the proposed framework on a group of Creative Coders which showed it is regarded easier than classical programming.

The framework is based on the ZOCP protocol build upon ZeroMQ which was demonstrated last year.

About 5 years ago it hit me that Corporations are never going to take responsibility for Software Libre compliance. Full Software Libre compliance actually affects their bottom line, and it's the responsibility of Directors to pathologically maximise profits. In fact, selling eco-conscious products that can be upgraded year-on-year, throwing away perfectly good components in the process, also adversely affects a Corporation's bottom line.

Competing with existing profit-maximising Corporations on "Software Libre Compliance" is not a strong selling point: nobody who isn't a programmer actually really cares, and they're not knowledgeable enough to upgrade the software anyway - they'd rather just throw the whole thing away and get a new one, in the naive hope that the new OS will somehow be better, cleaner, and free from the malware attacks that slowed down the perfectly good hardware they just discarded into landfill.

People are mainly influenced by money (saving it), cool-factor, convenience and fear. So the trick is to come up with a strategy that plays on all these four things. The EOMA68 Project thus was envisioned as a way to help people save money (because they can upgrade just like popping out a "Memory Card", they can now push a button and pop out the "Computer Card"), as well as help reassure them on personal security. Sending the laptop back for repair, you don't want the people in the shop to copy or rifle through your private data? No problem: pop out the "Computer Card" before sending it off... and incidentally you can pop that Computer Card into a spare base unit and carry on working.

Almost as an incidental side-line, then, the products being developed are Software Libre Compliant right from the ground up (not that the end-users really need to know that, as it's not a major selling-point to them). Some of the products being developed can even be RYF Certified (are FSF-Endorseable) - again, the average end-user doesn't care about this. However, Software Libre developers will know what's under the hood, and are being invited to participate in bringing these products to market. The first main products will be two EOMA68-compliant CPU Cards (one with an FSF-Endorseable Ingenic jz4775, the other with an Allwinner A20 dual-core ARM Cortex A7), a Micro-Desktop "base" and a 15.6in 1366x768 Laptop. The laptop's case is 3D-printable on a standard 200x200mm Mendel90, and uses bamboo laminate for the main panels, to save on plastic.

In short: where standard Hardware Corporations are set on maximising profits year after year, collectively they've left a gaping hole in the market that, with a little creative thinking, can be filled by someone who is willing to take active responsibility for doing things in a conscientious and principled way. The resultant products - which have an expected upgrade lifecycle of at least a decade - just happen to be really cool.

Infrastructure as a Service deployment has replaced traditional dedicated hardware in many datacentres.

But today's cloud computing also has its limitations, which makes it not suitable for applications with strict timing requirements.

That is why real time systems, like telecommunication, trading, and control systems, are mostly still deployed in the traditional way and can not make use of all the advantages IaaS deployments have to offer.

The talk is about a real time enabled OpenStack prototype, which enables real time virtual machines connected to the outside world with real time networking.

KVM has improved a lot with regard to hosting guests with real time requirements. What is still missing is the integration with a complete management stack so that users do not have to tune every detail themselves. We will present an ongoing project in which we use a stack of Preempt-RT Linux, QEMU/KVM, libvirt and OpenStack for RT CPUs. For real time aware I/O, device assignment currently is the best way to go, but that does not scale well. So we decided to implement networking using vhost-user combined with a DPDK-based software switch.

We will explain how we tuned the overall system and where we had to change individual components of the stack. There will be a presentation of preliminary results, and if time allows a short demonstration. It still is a prototype with some of the changes not suitable for mainline yet. So we will also discuss current limitations and close the talk with plans and ideas for future work.

GNU Guix allows creating higher level abstractions. This means you can have a short and elegant way to describe any source package. We added support for Ruby gems and Python modules to GNU Guix. We think the process of adding them is interesting for others who would like to support their language and or software stack.

The GNU software packaging project is packaging done right. Ruby deployment with rubygems used to be pretty good, years ago, but over time it has turned into a nightmare of dependencies. Tools like RVM, rbenv and bundler try to bring some level of control for running multiple versions of Ruby and gems, but over the last years they are showing their limitations clearly.

So when should you look at GNU Guix? You should look at Guix when you

are serious about software deployment
need to handle multiple versions of Ruby or gems
want clear isolation of dependencies
want clean separation of gems
want a reproducible environment

GNU Guix allows you to define a software package once with all its dependencies. Every time you install the package it gets reproduced exactly with its exact dependency graph, all the way down to glibc. See this figure. Whether you are a sysadmin who needs to deploy an exact Rails stack or you are a developer and need to support user environment, GNU Guix is the solution you require. Use cases are

test gems using multiple versions of Ruby
install concurrent rubies with or without linked openssl support
run minimal ruby to be exposed to the web
update ruby in production and roll-back after a problem
run multiple versions of the same gem against one ruby
run multiple versions of openssl dependencies

Use your imagination. The point is that you control the full dependency graph. Always. You can even give users rights to install and share software because the underlying system is ‘immutable’. Existing graphs can not be overwritten by others.

GNU Guix is a next generation software package installer with a range of features, including sane dependency handling, transactional and reproducible installs which can be rolled back. In short, GNU Guix has resolved the fundamental problems of software deployment and management. GNU Guix also should play well with Docker and VMs.

'GHDL What's new ?' will present the main changes in GHDL since last presentation at FOSDEM 2015: features added, new frameworks supported, new hosting, and future developments

The swiss-army knife on MP4 in your browser

The swiss-army knife on MP4 in your browser

RIPE Atlas is a global network of probes that measure Internet connectivity and reachability. More then 9000 hardware probes are hosted by the community of volunteers. Supported measurements are ping, traceroute6, DNS, NTP, and TLS. All the probes perform constant measurements towards root name servers, and the users are able to start their own measurements from up to 500 probes at the time, to the target of their own choice. All the results of performed measurements are publicly available as open data.

RIPE Atlas is a global network of probes that measure Internet connectivity and reachability. More then 9000 hardware probes are hosted by the community of volunteers. Supported measurements are ping, traceroute6, DNS, NTP, and TLS. All the probes perform constant measurements towards root name servers, and the users are able to start their own measurements from up to 500 probes at the time, to the target of their own choice. All the results of performed measurements are publicly available as open data.

In addition to the web interface & the API calls for starting your own measurements, and for downloading results, there is now CLI toolset. This open-source toolset is the newest addition to the large collection of tools written by RIPE NCC developers & the community of volunteers, individually or during two hackathon runs.

My goals with this presentation are: to encourage FOSDEM participants to contribute to the free & open source code related to RIPE Atlas & port the toolset to Linux/BSD distributions; to use the existing data, start their own measurements, and to share results by writing papers & giving presentations.

Vulkan is the new next-generation graphics API from Khronos that is meant to replace OpenGL for many high-performance graphics applications. The talk will focus on three main topics: The Vulkan API itself, the impact of of the Vulkan API on open-source software including both open-source applications and running closed-source applications on open-source operating systems, and support of Vulkan APIs in open-source drivers on Intel platforms.

The OpenGL API has been the standard for 3-D graphics on Linux and MacOS for the long as 3-D has existed on those platforms. (On Windows, the standard is usally DirectX, although OpenGL is also available.) In the last couple of years, there has been a substantial push for low-level and low-overhead API's similar to what game consoles provide. In response to thise, multiple new APIs have emerged: Mantle, DirectX 12, Metal, and now Vulkan. This talk will focus on Vulkan, as it aims to be the new cross-platform industry standard and the one that will be the most available for Open-source platforms and applications.

In the last 24 years since OpenGL was first released, a lot has changed in the world of graphics hardware and many of the concepts in OpenGL no longer map well to modern hardware and software. One such mismatch is that OpenGL uses a state machine model with a thread-local implicit context. While this wasn't a problem at the time, the prevalence of multi-threaded programming to take advantage of multi-core processors has made this a substantial pain-point when working with OpenGL. Vulkan and other next-gen APIs use a more object-oriented model where multi-threading hazards are more explicit. There are many other examples of where OpenGL no longer matches modern graphics hardware or programming paradigms. Vulkan seeks to solve a lot of these problems while also providing substantially lower CPU overhead and the latest in modern graphics features.

The Vulkan API also provides substantial opportunity to the free software community. Because there is so much industry momentum behind Vulkan, there will probably be substantial support from both Hardware and Software vendors. This means that we may see more availability of games and other high-performance graphics applications on Linux. It also means that free software can now get the benefits of more modern graphics APIs. Not only should Vulkan be a more performant API, but it should also be easier to integrate into toolkits such as GTK and Qt.

What software we use at mozilla to deliver our products. What we've used what we use and what we'll use.

Mozilla manages a bunch of servers. I'll explain why we have so many servers. Why we need them. I'll talk about the tools we use to manage them. Were we are going in the future. Mostly an IT oriented talk.

Nemo Mobile is a long time FOSS operating system. Created in 2012 as continuation to Meego Community Edition, it has been actively developed since then. The newest iteration of it is to use Glacier UI as its renewed User Interface, along with its Qt Components. These components are now used in the NemoTablet adaptation, which I will present in this talk, using Raspberry Pi2 as underlying hardware and its plethora of possible peripherals to create a true DIY tablet.

In this lecture, I will present the NemoTablet, a adaptation of Nemo Mobile as operating system, using the hardware from Raspberry Pi 2. Including a touchscreen and a miscellaneous powerbank, it is an enticing DIY tablet concept. Overall, the tablet adaptation, as well as mobile phone adaptation, have been the hilights of Nemo Mobile thus far. It is possible to extend this operating systems functionality far beyond this, as has been proven by eg. AsteroidOS, which uses Glacier UI fork and Nemo Mobile middleware for smartwatches.

With Raspberry Pi 2 introduction in February 2015, it was then possible to create an adaptation for it. This enables the myriad of functionality it offers, with its hardware provided. Initial adaptation was done originally for SailfishOS, but Nemo Mobile had the first run and checking that everything worked, before a closed system was installed. Nemo Mobile, however, was then not tried until later. The idea came once the official touchscreen by Raspberry Pi Foundation was released, so that a FOSS tablet could be built by anyone and used. Raspberry Pi 2 has non-free hardware, but Nemo Mobile itself is FOSS completely. As with all other adaptations, the questions regarding hardware freedom limitations rise for a good reason.

Homebrew is a popular package manager for OS X. Compared to most Linux package managers we have some pretty major differences from how we run the project (pull-requests on GitHub) to how we interact with the system (try to use system-provided libraries when possible) and use of root (we actively refuse to use it). Come and hear about how we'd do Homebrew differently if we were starting it from scratch today and what other package managers can learn from our failures and successes.

Newer open source projects are embracing "Open Core" licensing model, where key parts of the software are restricted under a proprietary license. This model is deceiving and worse than a fully proprietary licensing model. This talk discusses the threats of open core model and how to successfully build a fully free commercial software.

It has become a trend to start as fully open source project until it reaches a critical mass adoption and then switch to a partially proprietary model. Typically, management user interface or some high-end features are restricted to commercial customers. Open source community is treated like a bunch of hackers and hobbyists. There isn't a really good reason to adopt open core model.

• Proprietary vs Open Core vs Open Source vs Free Software
• How to commercialize Free software?
• How to get venture funding and still stay Open source?
• Impact of GNU (A)GPL vs Apache License for commercial software?

Gunicorn is known as a Python WSGI HTTP Server for UNIX. But today the WSGI specification shows its limits and people wants more. This talk will introduce the new Gunicorn released in January with a new IPC library usable in others Python programs to handle the concurrency and support HTTP2.

Gunicorn handles the concurrency using a pre-fork worker model: workers are spawned processes managed by a main process. Until now there is no dialog between workers and the master which can trigger some issues like the thundering herd. To solve it and prepare gunicorn to support new protocols like HTTP2, a new IPC library has been specifically written in pure python. Mostly inspired from imsg in OpenBSD (but also Mojo), this new library is entirely written in Python and can be used outside of Gunicorn.

This talk will present the following:

1) The design of Gunicorn 1, its pros and cons 2) Description of the new IPC library how you can use it in your own projects 3) The design of Gunicorn 2 and its usage of the new IPC library, how it can do more than simply WSGI and HTTP 1.1.

Most important design goal of Tizen 3.0 security framework is to separate applications from user private data and from fragile parts of the operating system. Another important aspect is security policy that is easy to configure. To meet these requirements, we combined usage of widely known DAC and one of the most simple Linux Security Modules - Smack. The talk will also cover set of tools used to control access to abstract resources (Cynara) and tools used to configure all needed policy mechanisms (Security-Manager). Finally, a new module for controlling multi-container virtual environments will be presented (Vasum), that is also part of the Tizen 3.0 security framework. Described security model is open source with repositories publicly available both on tizen.org and github. It is successfully implemented and used on Tizen 3.0 platform with increasing interest from other Linux distributions.

Presentation will introduce design of security framework created for Linux based system - Tizen in version 3.0. This framework main goal is separating third party applications running in user context from user private data and privileged resources (like devices, sockets and services providing access to sensitive resources). We have chosen to combine usage of DAC and MAC, for the latter choosing Linux Security Module - Smack, which is easy to configure and easy to understand. Smack is mainly used to protect data, which can be mapped to system resources - files, sockets, databases. Some resources are more abstract, so they need different kind of protection. Assuming that such resources would be provided by privileged services, each service is encouraged to check access permission through access control tool provided by system. During our research we discovered, that existing tools do not meet all of our requirements (as Polkit proved to be inefficient), hence we have created our own access control tool - Cynara. It's main purpose is to store system policy and provide interfaces for policy changes and permission checks. Such policy is based on identifier of possibly unprivileged application, user in which context this application is running at and privilege - abstract sensitive system resource. To expand possible types of supported policies, Cynara supports custom plugins, which can declare any type of policy. We created AskUser plugin as example, which produces policy based on user decision, through pop-up windows. For creating and maintaining of system policy Security Manager service was created. It allows to configure and enforce system policy through proper actions taken during application installation and launch. During installation application declares used privileges, then proper system policy is created to allow such usage. User is allowed to change system policy configuration for each application - granting or denying access to each declared privilege even after the application is installed. Finally, a new module for controlling multi-container virtual environments will be presented. This enables creation of containers which separate processes and graphical environments.

One of the best thing, that could have happened to LibreOffice is the development its online version.

We can edit typographic quality documents in a browser using arbitrary page layout with page styles, headers and footers, footnotes, linked frames, custom fonts, also with font features, like true small capitals and ligatures.

These WYSIWYG document editing and form filling capabilities aren't limited by incomplete web standards and clients, and they are based on the OpenDocument format and its embedded XML based form standard, XForms.

We have made minor, but important LibreOffice improvements, too, like changing the default, unprofessional ASCII apostrophe to the long-awaited typographic one (U+2019) in online and desktop versions of LibreOffice.

To solve the problem of the simplified toolbars of the online version, we allowed to use nearly all keyboard shortcuts of LibreOffice in the online version, also adding new ones for compatibility and better usage, for example the shortcut Ctrl-Alt-F for footnote insertion.

The presentation will show several online document editing examples, focusing on the typographic quality and easy layout management (like online usage of the OpenDocument character, paragraph, list, page and other styles, the strengths of Writer word processor), and the related developments.

The talk about software design elements that can help building high performance real time communication signaling servers, primarily based on experiences while developing Kamailio SIP server. It will look at the components in the message processing flows that can become bottlenecks and what are the options to deal properly with them, either directly in the code or via operating system tunings and configuration file parameters.

Postgres documentation says "Code support exists for M32R and VAX, but these architectures are not known to have been tested recently."

Challenge Accepted! :)

Trying to get Postgres running on the VAX emulator simh started as a whimsical exercise in necrocomputing with no obvious benefit. No users were known and as far as we could determine no users had existed for at least 10 years. In the end it turned up two bits of inefficient code that was depending heavily on IEEE floating point where floating point math wasn't needed at all. It also turned up unexpected issues in the automatic configuration on machines with very limited memory and most suprisingly a NetBSD kernel bug.

The MariaDB CONNECT storage engine now offers access to JSON file and allows you to see a external JSON file as a MariaDB table. The CONNECT storage Engine has the capability to auto discover a table structure when the table correspond to external data. The MariaDB CONNECT storage engine comes with a set of UDFs (user defined functions) to manipulate the JSON format. This JSON content can be stored in a normal text column. This approach can be used as a way to implement dynamic columns. Beside JSON the MariaDB CONNECT Storage Engine allows to access various file formats (CSV, XML, JSON, Excel, etc). It also gives access to any ODBC data sources (Oracle, DB2, SQLServer, etc). These various capabilities of foreign datasources access makes it a perfect tool for data integration.

The MariaDB CONNECT storage engine now offers access to JSON file and allows you to see a external JSON file as a MariaDB table. The CONNECT storage Engine has the capability to auto discover a table structure when the table correspond to external data. The MariaDB CONNECT storage engine comes with a set of UDFs (user defined functions) to manipulate the JSON format. This JSON content can be stored in a normal text column. This approach can be used as a way to implement dynamic columns. Beside JSON the MariaDB CONNECT Storage Engine allows to access various file formats (CSV, XML, JSON, Excel, etc). It also gives access to any ODBC data sources (Oracle, DB2, SQLServer, etc). These various capabilities of foreign datasources access makes it a perfect tool for data integration.

I would like to present a library for GNU Guile which is built on, and enhances, Guile's existing Getopt-Long implementation.

It adds: direct support for nested commands (e.g. foo bar --baz); automatic generation and parsing of configuration files; automatic --help message generation; automatic --version message generation; backward compatibility with getopt-long; fully functional approach (if desired).

Kubernetes is a powerful, open source, container orchestration / cluster management tool created by Google. It drew upon all the lessons learned from a near-decade of using containers at Google. In this session, we'll look beyond container orchestration with Kubernetes, but also taking a deep dive into more advanced feature such as autoscaling. But its most powerful feature is its versatile REST API which you can use to tailor Kubernetes to your needs.

Kubernetes is a powerful, open source, container orchestration / cluster management tool created by Google. It drew upon all the lessons learned from a near-decade of using containers at Google. In this session, we'll look beyond container orchestration with Kubernetes, but also taking a deep dive into more advanced feature such as autoscaling. But its most powerful feature is its versatile REST API which you can use to tailor Kubernetes to your needs.

In addition to the Kubernetes Autoscaler, We'll look at: - How to access the Kubernetes API securely - The different Kubernetes resources, such as Pod, Replication Controller, Service, etc. - How to update/manage your entire cluster using the API

We'll demonstrate all of the concepts via a custom autoscaler that scales a stateful application using custom metrics!

VirtualBox comes with a set of drivers and tools designed to improve integration between the systems running in it and the system it is running on. We have generally preferred to provide these ourselves, but Linux distributions also wish to do this (and do). This talk looks at the reasons, and invites discussion about how we can better address them.

My plan is to spend about ten minutes talking and ten discussing (discussion can continue after the talk of course). I won't expand much on the abstract for ten minutes of talk, but my hope is that this will help us and distributions to better cater to each other's needs. Clearly not all of the issues are specific to VirtualBox (our main issue is that we want to provide the latest and greatest even on distributions in maintenance mode), so the benefits of discussing them should be greater too. And of course, since VirtualBox is a popular tool for distribution development work, improving integration is likely to be a good thing for lots of people in the room!

Libervia is a multi frontend decentralized social network. This talk explain how Python has been a good choice for developing this software.

Building a decentralized communication software is a difficult task. The choice of the technologies to use when you start a new project will have a big impact on its life expectancy, and on the time you'll need to develop features.

We have choosed Python for our development, and we don't regret it. We'll do a feedback of our experience, and specially on:

• Twisted/Wokkel which are in the core of our project (asynchronous framework)
• Pyjamas that we are using to build our web frontend (python -> javascript transpiler)
• Urwid that we use for our console frontend
• Kivy that we use for our desktop/mobile frontend
• standard library modules which saved us a lot of time

and we'll talk about the global benefits to expect by using a popular language like Python.

Come and see LibreOffice Online in action. You will hear about the internals too - how do we use LibreOfficeKit, what's happening during the client and server communication, and how we designed the server to scale. This actually presents work of many people, so I hope to credit them in the presentation too.

HelenOS could not have been developed without certain tools such as compilers, interpreters and emulators. In many cases, these tools have been evolving or leaving their age of infancy at the same time as HelenOS. The long exposure to these tools gave us invaluable experience regarding their strengths and weaknesses. In this talk, I would like to share some of it.

Offline experiences are enabling more unique user experiences to naturally happen without requiring an Internet connection. From IoT devices like beacons to Mobile applications, we will go over why offline is a requirement for success and how we can create that experience by using an embedded JSON database for local storage to replicate data to the cloud.

Offline experiences are enabling more unique user experiences to naturally happen without requiring an Internet connection. From IoT devices like beacons to Mobile applications, we will go over why offline is a requirement for success and how we can create that experience by using an embedded JSON database for local storage to replicate data to the cloud.

With the advent of the digital transformation in today’s always-connected world, users expect to have a mobile experience that is immediate, pervasive, and aware. In this way, it is crucial to build apps that meet these expectations. Specifically, it’s building mobile apps that are always available, regardless of network connectivity and speed.

In this session, you will learn what it takes how to build an embedded and mobile solution that has a consistent user experience, both online and offline. This includes:

• Beacons & Mobile solutions & demo • Syncing the data • Storing the data • Securing the data • Cross platform data modeling

You will walk away with an understanding of the design patterns required to build an app that works online and offline using a NoSQL backend – all this, through a BlueTooth Beacons and using open source technologies to sync, store and secure your data.

Ada Doom 3 is an open source project created as both an experiment and as a serious attempt at making a Windows game engine capable of fully rendering Doom 3 assets.

Engineering a complete OS media layer and 3D engine that facilitates multiple platforms presents many unique challenges. These challenges and solutions will be discussed.

I will also cover how Ada aided in the process of reverse engineering the half million line Doom 3 BFG (Id Tech 4 BFG) code base and how its typing system helped steer the development of Ada Doom 3 to its current state.

Nowadays there are many open source tools that are able to simulate either VHDL or (System)Verilog but none of them has the goal to address the problem of a mixed language simulation, that is, a simulation that involves more than one language at a time. In fact, people can not use multiple hardware-description languages in a design unless they rely on a proprietary solution.

After an introduction about compilers and simulators, the focus will move to review potential problems and solutions for the design and the implementation of an event-based digital mixed-language simulator.

In this session we will show how to build a simple, cheap and portable testing lab to run and capture usability studies with mobile devices.

Back in 2009 we decided that recording usability tests for mobile devices was too hard and too expensive, and that logistical issues were preventing people from running sorely needed usability studies for their mobile software. The outcome of that was crappy mobile software all around.

There had to be a better way, so we set to find it. And find it we did. We called it "Do it yourself mobile usability testing", we released it under a Creative Commons License, and has been doing the rounds in design circuits ever since. We have showed it at EuroIA, the IA Summit, South by Southwest Interactive, Mozfest, UX Spain, UX Sofia, UXLX ... we can't even remember all of them. We now want to show it at FOSDEM, and do justice to the open nature of the project from its inception.

The session will skip the theory bits (20 minutes is not enough), but it will include a brief review of the most common capture approaches for mobile usability studies. Then we build the usability lab in front of you, so that you can see how easy it is, how cheap ... and how fun!

Imagine you receive a report of a bug which causes a segfault (i.e. a memory exception) in the HotSpot Java VM very occasionally. This bug only occurs about one time in ten; it might take many hours before it happens. It has only been observed when running one particular piece of proprietary software. It only seems to occur on one large machine when running many concurrent threads and a huge heap. There is a clue: it only seems to happen when running the parallel scavenge garbage collector. But you've no real idea of how the garbage collector works.

This happened to me in 2015. I'm used to being able to find and fix bugs, but this one resisted all of my attempts for a long time. As far as I can recall it's the most difficult bug I've ever fixed. In hunting this bug I used every tool available to me as a HotSpot developer. I'll describe them and how they were used.

We don't much talk about debugging. Many of us spend much of our time doing it, but not talking or writing about this important activity. We should talk about it more. If there's time it would be good to swap war stories.

When Firefox crashes, it asks you to submit a crash report. If you send it (please do), it actually helps us at Mozilla to improve Firefox. The same is true for some other data that your browser can provide. This talk will look into what mechanisms exist, what the data is, and how we use it to improve Firefox.

We will give a short presentation of the most important changes that will be added in Kodi version 17.

We will give a short presentation of the most important changes that will be added in Kodi version 17. Compared to version 16 there will be more noticeable changes to the user. It ranges from long awaited features to deep core code changes. Be sure to visit if you are interested to know what we are working on.

In this talk we will learn a bit about how USB devices can do evil things to your system and introduce a new tool, called USBGuard, that helps you to defend against USB-based attacks. The USBGuard software framework helps to protect your computer against rogue USB devices (a.k.a. BadUSB) by implementing a firewall-like system for whitelisting and blacklisting the devices based on their attributes. Finally, some of the advanced and planned features like USB traffic monitoring or network bound USB disk encryption will be presented.

In this talk we will learn a bit about how USB devices can do evil things to your system and introduce a new tool, called USBGuard, that helps you to defend against USB-based attacks. The USBGuard software framework helps to protect your computer against rogue USB devices (a.k.a. BadUSB) by implementing a firewall-like system for whitelisting and blacklisting the devices based on their attributes. Finally, some of the advanced and planned features like USB traffic monitoring or network bound USB disk encryption will be presented.

Openfire is almost universally recognised as the worst XMPP server, and well known as having been dropped by its original authors, and left to rot, unmaintained and buggy. So why has it just made a 4.0 release, and who cares, anyway?

Many years ago, when the majority of this audience were still in school, there used to be an amazing server called Jive Messenger. After two renames, it was called Openfire, and everyone loved its powerful admin interface, full modern featureset, and astounding integration capability.

Then Jive decided they didn't want to be in the XMPP business anymore, and threw it over the wall, leaving it to languish in the bitrot bin. Everyone - and I mean everyone - knew that using Openfire was a bad idea.

Now, it's back - but did it ever go away, and does it really deserve the reputation of the worst XMPP server?

Dave Cridland is the Project Lead of Openfire, despite hating Java and being not very good at it, and in this talk will attempt to take credit for the revival of a much-loved server that he has had nothing much to do with.

About 5 years ago it hit me that Corporations are never going to take responsibility for Software Libre compliance. Full Software Libre compliance actually affects their bottom line, and it's the responsibility of Directors to pathologically maximise profits. In fact, selling eco-conscious products that can be upgraded year-on-year, throwing away perfectly good components in the process, also adversely affects a Corporation's bottom line.

Competing with existing profit-maximising Corporations on "Software Libre Compliance" is not a strong selling point: nobody who isn't a programmer actually really cares, and they're not knowledgeable enough to upgrade the software anyway - they'd rather just throw the whole thing away and get a new one, in the naive hope that the new OS will somehow be better, cleaner, and free from the malware attacks that slowed down the perfectly good hardware they just discarded into landfill.

People are mainly influenced by money (saving it), cool-factor, convenience and fear. So the trick is to come up with a strategy that plays on all these four things. The EOMA68 Project thus was envisioned as a way to help people save money (because they can upgrade just like popping out a "Memory Card", they can now push a button and pop out the "Computer Card"), as well as help reassure them on personal security. Sending the laptop back for repair, you don't want the people in the shop to copy or rifle through your private data? No problem: pop out the "Computer Card" before sending it off... and incidentally you can pop that Computer Card into a spare base unit and carry on working.

Almost as an incidental side-line, then, the products being developed are Software Libre Compliant right from the ground up (not that the end-users really need to know that, as it's not a major selling-point to them). Some of the products being developed can even be RYF Certified (are FSF-Endorseable) - again, the average end-user doesn't care about this. However, Software Libre developers will know what's under the hood, and are being invited to participate in bringing these products to market. The first main products will be two EOMA68-compliant CPU Cards (one with an FSF-Endorseable Ingenic jz4775, the other with an Allwinner A20 dual-core ARM Cortex A7), a Micro-Desktop "base" and a 15.6in 1366x768 Laptop. The laptop's case is 3D-printable on a standard 200x200mm Mendel90, and uses bamboo laminate for the main panels, to save on plastic.

In short: where standard Hardware Corporations are set on maximising profits year after year, collectively they've left a gaping hole in the market that, with a little creative thinking, can be filled by someone who is willing to take active responsibility for doing things in a conscientious and principled way. The resultant products - which have an expected upgrade lifecycle of at least a decade - just happen to be really cool.

(Please note that this talk replaces "Emulating the Nintendo 3DS" by Tony Wasserka.)

With the new compiler and virtual machine in Guile 2.2, Guile hackers need to update their mental performance models. This talk will give a bit of a state of the union of Guile performance, with an updated overview of the cost of various kinds of abstractions. Sometimes abstraction is free!

This talk will show stories from the trenches of developing tests for SSSD and Samba. How we developed complete integration tests that exercise all the capabilities of our software and run in environments without a real network access, without requiring root or sudo or touching the important OS interfaces.

The authors of this talk work on SSSD, Samba and libssh - software that communicates over the network, often requires root access and communicates through OS interfaces. In this talk, we will show how we developed complete integration tests that exercise all the capabilities of our software and run in environments without a real network access, without requiring root or sudo or touching the important OS interfaces.

In addition, our goal was that the tests must be easy to develop and must run both locally on developer's machine as well as inside popular CI engines of today, like Travis or Semaphore. To meet these goals, we had to leverage existing testing tools, but also build new ones such as pam_wrapper or libpamtest to be able to test OS-level PAM authentication and authorization.

This talk will be useful for developers who write tests for software that is normally not easy to test -- attending the talk will show you how to test complex software systems in isolation.

I'll introduce differential dataflow, an open-source analytics platform, and describe how it enables fundamentally new approaches to large-scale graph processing. Specifically, we'll see how to fairly easily write and run standard graph analyses, whose output results are automatically updated as their inputs changed. On billion-edge graphs this approach can both be more efficient than platforms like GraphX and provide sub-second update times.

(stolen from https://github.com/frankmcsherry/differential-dataflow)

Differential dataflow is a data-parallel programming framework designed to efficiently process large volumes of data and to quickly respond to changes in input collections.

Like many other data-parallel platforms, differential dataflow supports a variety of data-parallel operators such as group_by and join. Unlike most other data-parallel platforms, differential dataflow also includes an iterate operator, which repeatedly applies a differential dataflow subcomputation to a collection until it converges, especially useful in the context of graph processing.

Once you have written a differential dataflow program, you then update the input collections and the implementation will respond with the correct updates to the output collections. These updates (both input and output) have the form (data, diff), where data is a typed record and diff is an integer indicating the change in the number of occurrences of data. A positive diff indicates more occurrences of data and a negative diff indicates fewer. If things are working correctly, you never see a zero diff.

Differential dataflow is efficient because it communicates only in terms of differences. At its core is a computational engine which is also based on differences, and which does no work that does not correspond to a change in the trace of the computation as a result of changes to the inputs. Achieving this property in the presence of iterative subcomputations is the main "unique" feature of differential dataflow.

This session is about using GNU debugger (gdb) as a tool to study MySQL internals (namely, InnoDB locks and metadata locks) and as a last resort in cases when server hangs or has to be restarted for other reason. It never hurts to try a trick or two before giving up and restarting.

Sometimes MySQL DBAs have to work with stalled/hanged/unresponsive MySQL instance, where their usual SQL-based tricks do not work any more. Sometimes they can not even connect to check what's going on inside server.

In other cases they know what to do and everything still works, but they have to implement changes to read-only server variables. Server restart is often not an option in production, as it means some downtime and may cause negative performance impact.

In these cases one could do something given read and write access to server memory/internals. Here comed gdb, that, alone with careful reading of the source code helps to often resolve the problems described above. During this session I'll show what can be done with gdb when server already is in troubles, and how to use gdb to "see" and understand MySQL internals (like InnoDB locks or metadata locks) better.

LibreOffice Writer was always capable of mass-sending mail using mail merge, but setting it up is far from easy. One obstackle there is having to create three different documents: a Writer one, a Base data source and e.g. a Calc document containing the real data. LibreOffice 5.1 has a new feature to allow embedding the data source definition into a Writer document, meaning you can get along with e.g. a Writer and a Calc document. Come and see how it's implemented, where are the still rough edges and how you can help.

EDF develops and uses a custom Linux distro which has been based on Debian since 2003. This distro covers scientific workstations, HPC clusters and servers. Each major version is maintained in-house for security and bugs with a five-year life cycle. Specific tools ensure business application compatibility across different releases. Everything is streamlined towards industrial R&D and fits in corporate IT infrastructures. This talk will present the project goals, features and announce the creation of a community site for collaborative Open Source development of the distro. A dedicated kick-off event will also be announced in Paris during 2016. We are looking forward to questions, remarks and contributors.

Control Groups: how to manage resources inside and outside of a container in csope of new cgroups unified hierarcy interface

The talk will briefly covers, what CGroups unified hierarcy is, what are the two major nowadays CGroups frontends: systemd and Cgroups Manager, and what there goals are. Will be described, what is common and what is different between them, and what is the future of these two projects in cscope of CGroup control. Will be described, why these two projects doesn't suit OpenVZ needs, and what are we going to do achive efficient resources utilisation and management in OpenVZ.

The world of multimedia is one which is slow and reluctant to adapt new technologies, regardless of how inefficient and inflexible older technologies are in comparison. Such has been the case with all common video, audio and container formats spread through the internet. Historically, the number one reason for this has been poor support by popular programs, like IE6 not supporting PNG files or the APNG vs MNG and in recent times GIF vs WEBM. There have however been exceptions to this, such as the lighting fast adaption of VP9 by Google, which was an achievement only possible after developing the format themselves and pushing support for it through the popular Chrome browser. Although some browsers were not as quick to follow this trend (as they had to include an additional library dependency) this demonstrated to the world of multimedia that it is indeed possible to quickly adapt new technologies as long as they're an order of magnitude better than the current solutions and, more importantly, support for such formats would have to be available through the browsers themselves as soon as major providers start publishing content and services using it. Since a large majority of current browsers like Chrome, Firefox and their derivatives already include libavcodec (a library from the FFmpeg project to provide decoding and encoding of various formats), support for new formats within the library itself even before having their specifications published could speed up adaption and reduce future work load. This talk will explain both the politics behind doing this work, and will give a more technical description of what the Daala codec currently is, as well as discuss the challenges of implementing it in FFmpeg's libavcodec, and finally discuss where it stands right now as the future heir to the throne of open video formats.

Yosys (Yosys Open Synthesis Suite) is an Open Source Verilog synthesis and verification tool.

Project IceStorm aims at reverse engineering and documenting the bit-stream format of Lattice iCE40 FPGAs and providing simple tools for analyzing and creating bit-stream files, including a tool that converts iCE40 bit-stream files into behavioral Verilog. Currently the bitstream format for iCE40 HX1K and HX8K is fully documented and supported by the tools.

Arachne-PNR is an Open Source place&route tool for iCE40 FPGAs based on the databases provided by Project IceStorm. It converts BLIF files into an ASCII file format that can be turned into a bit-stream by IceStorm tools.

This three projects together implement a complete open source tool-chain for iCE40 FPGAs. It is available now and it is feature complete (with the exception of timing analysis, which is work in progress).

We will talk about porting Smart.JS, an open-source JavaScript-based IoT platform, to two very different hardware platforms: Espressif ESP8266 and TI CC3200, the difficulties we encountered and lessons that we learned working with them.

We will describe the Smart.JS platform (focusing on parts other than the V7 Javascript interpreter itself, which is the focus of another talk), and give the audience a taste of the embedded development process for two different platforms: one from an established player in the field and an up-and-coming recent entrant, very popular with enthusiasts. We will discuss the hardware, the SDK and the developer interactions, the challenges that we had with each of them and how we tackled them in each case.

During the year 2008, the awesome window manager jumped in and picked a programming language to allow its users to extend their configuration beyond the limit of the possible. History shows that Lua was picked and Guile completely ignored. Fast forward 7 years later: awesome is still used by tens of thousands of geeks around the globe who write Lua every day. This talk is going to relate how awesome ended up with Lua, how wonderful and terrible it was, and how and why Guile was discarded.

During the year 2008, the awesome window manager jumped in and picked a programming language to allow its users to extend their configuration beyond the limit of the possible. History shows that Lua was picked and Guile completely ignored. Fast forward 7 years later: awesome is still used by tens of thousands of geeks around the globe who write Lua every day. This talk is going to relate how awesome ended up with Lua, how wonderful and terrible it was, and how and why Guile was discarded.

In this session I'll show an overview of oVirt (Virtualization Management), Foreman (Host Lifecycle Management), and Katello (Content Management), and show how we use the latter two in oVirt to give a Powerful Virtualizaed Data-Center Management system.

Foreman support already started in oVirt 3.3, where we allow to add Foreman-managed hosts as oVirt hypervisors. In 3.5 we've also added Bare-Metal provisioning - get a hypervisor running in one Click! In 3.6 we've added support for showing content information for Hosts/VMs managed through Katello. And the sky's the limit!

In addition, in 3.6 we introduced the host upgrade manager feature in oVirt, so I'll talk about that as well, and show how you can easily upgrade your hypervisors. In the session I'll deep dive into each part of these functionality, covering also future plans to integrate the three to give a wider solution to our users.

Inspired by the phrase 'We mean design in the broadest sense' on opensourcedesign.net, this talk will discuss what are the opportunities and barriers of introducing open source mentality and workflow in domains of design that aren't software related. Engineering, architecture, even print and product design can all benefit from the open source way as born and developed in the software world. The current state, the arguments that can counter the common reservations and the possible barriers for introducing open source in a design shop.

Slides: http://play.qwazix.com/fosdem16/

They will automatically advance while the talk is running and they will be free to browse afterwards

Inspired by the phrase 'We mean design in the broadest sense' on opensourcedesign.net, this talk will discuss what are the opportunities and barriers of introducing open source mentality and workflow in domains of design that aren't software related. Engineering, architecture, even print and product design can all benefit from the open source way as born and developed in the software world. The current state, the arguments that can counter the common reservations and the possible barriers for introducing open source in a design shop.

The focus of the talk will be on the Engineering and Architectural design which have the most potential for an effective introduction to open source workflows and publication of final works. The relationship with the clients, equipment manufacturers and the state, the nature of the most common projects and the current mentality of professionals all play their role in the success or failure of an open source model of work.

Although a lot of work has been done already, many IT departments in public administrations continue to struggle with these topics. Based on my experience as former head of the team responsible for the implantation of the European Commission's IDBAC programme and my current contacts as OpenForum Academy fellow, I will discuss the following topics:

- Public procurement, IT architecture, interoperability and the use of standards
- The European public procurement legislation and the use of open source software and the acquisition of open source software related services
- The European legislation on standards and the problems this causes for open source developers, software architects and software procurers
- The construction of custom software paid for by public funds and the 4 freedoms
- Sharing, re-use and co-development of custom software by public administrations; the European Union Public License and its relationship to other open source licenses
- How can public servants be active in existing open source communities
- How to convince the IT service providers to offer to public administrations solutions based on open source software

On each of the topics, interaction with and feedback from the audience will be sought.

Although a lot of work has been done already, many IT departments in public administrations continue to struggle with these topics. Based on my experience as former head of the team responsible for the implantation of the European Commission's IDBAC programme and my current contacts as OpenForum Academy fellow, I will discuss the following topics:

USB is considered by many people to be some kind of black magic or place where the dragons live... During this talk Krzysztof is going to smash this urban legend and show that creating custom USB devices may be both fast and easy!

The goal of this presentation is to create our own USB device on a cheap development board. To do this we have to start our journey with some brief introduction to USB protocol. Then we will run through its Linux implementation to scare off all the dragons. The next steps are open source projects which support user in creating their own USB devices using existing kernel infrastructure. Each part is supported by a suitable demo to ensure that there isn't any black magic.

As in abstract.

For the last 11 years, the Python language have been in used and abused by the Mercurial command line tools. We are now looking back at the various trap we feel into and sharing tricks about how to get the best performance and flexibility out of Python.

Since 2005, Mercurial developers, take advantages of the Python language. This is long enough to explore many aspect of the language and be surprised multiple time. Some of the idea we tried were so great that latest version of the language have native support for them while some other were terrible terrible mistake that we are still trying to get away from.

This Talk will first go over some of our terrible mistakes and great success. Then we will focus on our work around performances. We'll go over various profiling techniques, various tricks to get the most CPython and finally our exploration of latest Pypy advantages and limitation for a command line tools.

A half-hour slot has been reserved for much needed interaction and informal discussion among Ada DevRoom participants and anyone potentially interested in Ada.

Arguman.org is an open source argument mapping platform which was developed by an avid community started in Turkey and spread to the world. It provides a visual critical thinking discussion platform written in python / django and used various open source libraries for various features. Arguman has 500+ commits and 24+ developer and more non-developer contributers. For the last couple months, the community is working on building a semantic network between arguments and calculating the objection and supporting rate of arguments.

(Please note that this talk replaces "libimobiledevice.org - iOS devices on Linux" by Martin Szulecki.)

The talk will present a Linux system completely built with Address Sanitizer. Address Sanitizer is a protection mechanism in the gcc and clang compilers that detects and prevents various memory corruption bugs.

Common C coding bugs like buffer overflows, use after free errors and other errors accessing invalid memory are still amongst the most prevalent security issues in today’s software. Modern operating systems have mitigations like ASLR and Stack Canaries, but they can often be circumvented. The gcc and clang compilers come with a feature called Address Sanitizer (short: ASAN). It detects memory access bugs at runtime and stops the program execution. Compared to other previous solutions Address Sanitizer is relatively fast, although it still causes a significant performance hit. It can usually be used with real world software without any modifications. Address Sanitizer is primarily designed as a debugging tool and as such it has been remarkably successful. The speaker has used ASAN in combination with fuzzing to successfully uncover a large number of bugs. But Address Sanitizer could also be used in production. Recently the Tor project started publishing nightly builds of its browser bundle protected with Address Sanitizer. The speaker will present a fully working Linux system (based on Gentoo) with everything except a few core parts compiled with Address Sanitizer. Just trying to do that already uncovered several memory access bugs in core packages like bash and coreutils.

What HTTP/2 is, what it means for browsers and sites and not the least how the adoption rate looks like now.

At FOSDEM 2015 Daniel presented what the HTTP/2 protocol was going to become. It subsequently shipped to the world as RFC 7540, has been adopted by all major browsers, the most popular web servers and an ever growing number of sites. This is a recap of what the protocol is, what it means for browsers and sites and not the least how the adoption rate looks like now. What's the biggest obstacles in the way for turning on HTTP/2 on your site?

Libreboot - free software BIOS replacement (boot firmware), based on coreboot, for laptops and servers, and x86 (Intel/AMD) and ARM hardware.

Libreboot is a free software BIOS replacement (boot firmware), based on coreboot, for Intel, AMD and ARM based systems. Backed by the Free Software Foundation, the aim of the Libreboot project is to provide individuals and companies with an escape from proprietary firmware in their computing. Libreboot is also being reviewed for entry as an official component of the GNU system.

Boot firmware is the low-level software that runs when you turn your computer on, which initializes the hardware and starts a bootloader for your operating system. Libreboot currently supports laptops and servers, on x86 (Intel and AMD) and ARM (Rockchip RK3288), with more hardware support on the horizon. The purpose of this talk is to describe the history of the project, why it started, why it's important, where it's going and, most importantly, to tell people how they can get involved.

Leah also runs the Minifree (formerly Gluglug), a company that sells computers with libreboot and Trisquel GNU/Linux pre-installed.

More information about libreboot can be found at http://libreboot.org/

Code review is the manual assessment of source code by human reviewers. It is widely recommended practice in software engineering and it is widely adopted both in industrial settings and in open source projects. What can we learn if we compare code review in OSS projects and at Microsoft? In this talk, I will present and compare the results of two studies about code review: One conducted at Microsoft and one conducted in open source settings. We learn that--despite the differences in environments, incentives, languages, and used tools--code review at Microsoft and in the analyzed open source projects have one common trait: The outcome. Unfortunately, this outcome does not match the main reasons why developers say they do code reviews: Finding defects. I will discuss why this happens and what we can do about it.

In summer 2013, we investigated expectations, outcomes, and challenges of code review at Microsoft. I conducted face-to-face interviews with several professional developers, performed a deep analysis of the code review data across many products at Microsoft (e.g., Excel and XBox), and administered a company-wide survey answered by more than 1'000 Microsoft developers and managers. We found that outcomes clearly do not match the expectations from various angles and across all product groups. The study was published at the International Conference on Software Engineering in 2013 (see attached file). After this, we investigated the outcomes of code review in two active open source projects with several years of development (ConQAT and GROMACS). We found a staggering similarity in the outcomes of code review at Microsoft, despite the great differences in the environments in which code review are conducted and the incentives. The study was published at the Working Conference on Mining Software Repositories in 2014 (see attached file). In this talk, I will present the details of these studies, their results, and the motivation we gave to this difference between code review expectations and outcomes, and how I am trying to make code review work as expected with my research.

This talk is about orchestrating Percona XtraDB Cluster (PXC) nodes atop Google Container Engine (GCE) with Kubernetes. PXC provides for synchronous replication among MySQL nodes through the WSREP (writeset replication) API, and Galera plugin which implements it, to provide group communication and configuration through extended virtual synchrony (EVS). While it can be run in isolation, GCE provides other architectural elements such as fluentd for logging, etcd for co-ordination, skydns for DNS among others, which are vital in this design.

This talk is about orchestrating Percona XtraDB Cluster (PXC) nodes atop Google Container Engine (GCE) with Kubernetes. PXC provides for synchronous replication among MySQL nodes through the WSREP (writeset replication) API, and Galera plugin which implements it, to provide group communication and configuration through extended virtual synchrony (EVS). While it can be run in isolation, GCE provides other architectural elements such as fluentd for logging, etcd for co-ordination, skydns for DNS among others, which are vital in this design.

Key elements of the talk will be:

a) Details of PXC and synchronous replication that it provides while ensuring ACID compliance with MVCC. Extended virtual synchrony (EVS) will also be described as are its CAP limitations. Finally, existing deployment strategies of PXC will also be mentioned.

b) The Docker image built for PXC. The design is intended to be flexible and extensible, either from git or from release packages.

c) Initial docker-compose, designing and porting to Kubernetes. Docker-compose has been used for a while to bring up a ‘N’ node cluster with minimal configuration. Some of the elements in this design cannot be used with Kubernetes as is. Thus, details of porting will be discussed as follows:

i ) Each PXC node goes into a Pod. Same Pod may also contain other optional services like xinetd or haproxy. While having Pods may be sufficient, it will not be making use of Kubernetes fully. Hence, Replication Controllers (RC) are used to control Pod placement and lifetimes. The Pod and RC configuration will be discussed here.

ii) The nature of architecture and bootstrapping of cluster. PXC is a master-less cluster which requires a bootstrapped node that others can connect to in order to form the cluster. Kubernetes, while not allowing for direct linking among containers, allows for service endpoints. A ‘cluster’ service endpoint is created for cluster group communication and client connections. The service endpoint also provides load-balancing and high availability as desired side effects. This addresses the agnostic approach and allows for simpler, more elegant bootstrapping for PXC (a strong benefit of deployment with Kubernetes over normal deployment of PXC).

iii) Database itself is mounted through volumes allowed for by both Docker and Kubernetes. This also allows for persistence and separation of data and design.

iv) Dynamic generation of JSON Pod configuration is required to allow for certain runtime elements to be injected into it.

Finally, future work will be discussed: benchmarking, application Pods, CAP testing (akin to jepsen), integration with Apache Mesos and so on.

The Go code for this is already up and running at https://github.com/ronin13/pxc-kubernetes.

A talk on the challenges and solutions to package management on Genode, which lacks a canonical file system and a root user.

During the last year on two hackfests I worked on exporting custom shapes from LibreOffice to OOXML (DrawingML). The limited time did not permit a systematic approach or full implementation, rather I wanted to solve bugs reported by users. I will present the problems, the results, the tools which I used, and possible future developments.

Come present your topic to the Distributions audience!

Miss the CFP? Think of a topic on the way here? From a different devroom and want to present your topic to the distributions community?

Lightning talks are for you! Come by the devroom and sign up for a short speaking slot.

Pre-Accepted Talks: * Linux Server Administration for non-expert users - Alessio Fattorini

Using a Linux server for an organization infrastructure has many undeniable benefits: stability, security, hardware performance, TCO, freedom. But that doesn't mean there aren't some drawbacks (usually outweighed by the benefits), that we should consider and try to reduce or remove.

Introducing a Linux server in an organization usually has a pretty significant impact: new process, new interface to learn (CLI), new commands and services, new way of doing pretty much everything on the infrastructure. Unexperienced (on Linux) members of the IT team will be most likely skeptical of such a new solution, therefore we have to deal with the resistance to change, which is common and understandable, or we will end up with part of IT team members being left behind by these changes to their work routine. Improving this situation is mandatory and that’s exactly the mission of the NethServer project: make a Linux distribution for servers more accessible, easier to adopt and simpler to understand, thanks to a powerful and extensible web interface that simplifies common administration tasks. Because we believe simplicity can still be powerful.

Most realtime collaborative editors make use of a class of algorithms known as Operational Transformation. Most of these algorithms require that the server and the client run the same algorithm otherwise risk desynchronisation - the nightmare of realtime collaboration algorithm designers. I will propose a new method of finding consensus using a blockchain of the type originated in bitcoin. This algorithm uses the blockchain to find consensus on the state of the collaborative document or data-structure then applies the Operational Transformation on the client side without requiring any help from the server. Such a setup simplifies the server side, allowing multiple implementations of the server, for example in different programming languages, but it also allows the client-side to use encryption in order to keep the data secret from the server. Finally, I will propose an extension to this algorithm which, borrowing again from bitcoin, makes the system able to function purely as a peer-to-peer system, providing high resilience and greater security.

Lecture Notes:

For those who don't know me, I'm Caleb James DeLisle, I'm a researcher at XWiki where we make technology to help people collaborate and share information. Today I'm going to talk about a realtime collaboration algorithm but in order to fill in the history for this, I need to explain a bit about about distributed consensus. Consensus is something which we need more often than we know and until recently we did not know how to do distributed consensus.

The concept of distributed consensus was made really popular by the Bitcoin protocol. Not only did Bitcoin claim to achieve distributed consensus but it claimed the ability to achieve consensus amongst machines operated by mutually antagonistic parties. There is, however, another aspect of distributed consensus which gets a bit less attention but has probably has had as much impact if not more. That is consensus in distributed "no-sql" databases. To give a little background, it's interesting to look at how traditional high-volume databases are architected. At a financial institution you usually would have an Oracle database with master/slave replication and sharding where possible but where you have, for example, the accounts database, you ended up with this bottleneck in a single machine. If you were to split up this master database then you run the risk of what in bitcoin parlance is known as the "double spend", I send money to Alice and Bob at the same time and my account can't support both. NodeA thinks Alice got paid and the transfer to Bob is invalid, NodeB thinks Bob got paid and the transfer to Alice is invalid, thus the distributed database becomes desynchronised. This problem comes up in almost every type of database and the traditional solution has been to make sure the main database ran on one computer. Obviously total reliance on a single machine is a recipe for problems and to solve these problems, organisations spent money. In traditional enterprise settings, the database master has become the crown princess. It's not uncommon to see RAIDs containing multiple mirrored high availability SSDs or even battery backed RAM based storage. Microprocessors looked more like something one would expect to see in a top end gaming machine and duplicating an entire master with a "hot spare" is not uncommon.

In the tech world, there wasn't the money to run these beasts and with the margin of error in their applications being far wider than those in the financial industry, the stage was set for something different to emerge. Google BigTable, Amazon Dynamo, Hadoop, Cassandra and Mongodb were the beginning of a new approach. Behind the changes to the database query language was the ability for multiple master nodes. Unlike bitcoin, no-sql did not promise to work with nodes which are trying to attack eachother but at least with honest nodes it promised to come to reach agreement. The logic of this was astonishingly simple, servers would tell each-other about the transactions they receive but they would tag them with the id of the previous transaction and a timestamp, if it received a conflicting transaction with an older timestamp then it would just revert it's own and apply the other.

So what does all of this have to do with collaborative documents? Well a collaborative document is another thing which really really needs to be the same for all of the people editing it. If you are working on a document and your version is different from one that someone is collaborating on, that's a big problem. In collaborative documents, two people altering the same content is a very common situation and instead of simply rejecting one change, the state of the art is to try to transform it into what the user "probably would have wanted" using what is known as Operational Transformation.

The problem with the traditional method has been that the server and the clients both needed to have the Operational Transformation functions and those functions are famously difficult to implement for collaborative editing of rich text.

Secondly this type of algorithm implies that there must be a central server and that server must be able to read all of the content which is being edited. From a privacy standpoint it's not the best deal but the real difficulty is that with the same algorithm needed on the client side and on the server, programming languages in which the server can be implemented are quite limited.

We have developed a new algorithm called ChainPad, this algorithm makes use of a limited blockchain. Like no-sql, ChainPad does not resolve cases of mutually antagonistic parties but as long as the people editing are not trying to attack you, the algorithm will find consensus, even with out-of-order messages from a peer-to-peer transport.

Even without going to full peer-to-peer, we can do zero knowledge. Zero knowledge means that the server which hosts the data does not have the ability to read it. With traditional realtime this is not possible but with CryptPad, the server does nothing more than to pass messages between the clients.

Session with the GNU Guile and LUA communities

Session with the GNU Guile and LUA communities

In the recent years, affordable Brain-Computer Interfaces are becoming more accessible for consumers. Applications range from controlling computers / machines, biofeedback and Quantified Self. At first sight, the current generation of commercial devices seem to be decent in their functionality, and various use cases are suggested. However, neurophysiological signal quality, as well as limitations of software and hardware hackability are among the greatest issues and hurdles towards advancement in user experience. This is why we started to work on Brain-Duino, an open-source brainwave amplifier shield for the Arduino and other microcontrollers.

Slides: http://brain-duino.com/brainduinofosdemfinal.pdf

Brain-Duino is a high quality, low noise and affordable EEG / BCI for hackers, makers, researchers, artists and other enthusiasts. This talk will be about how the brain-Duino project started, where it is now and where it is going. We will briefly explain how EEG works and how to build one, more specifically we will show the parts that Brain-Duino consists of. During the FOSDEM we have a table for you to try out the Brain-Duino and Neurophlex / IBVA software to visualize your brainwaves.

The Marlin renderer is an open source java2D anti-aliasing renderer, forked from the OpenJDK's Pisces renderer, i.e. a pure-Java software renderer. This small project, with only 2 contributors (Me and Andrea Aimé), is hosted on my github (GPL v2) since 01/2014 to provide a faster alternative with very good scalability to both Pisces & Ductus (closed-source C) renderers. I made an important personal effort to optimize the memory footprint, rewrite Pisces's algorithms, run regression tests & our MapBench benchmarks (serialized maps). Many binary releases were published in 2014, compatible with both OpenJDK & Oracle JDK 7 / 8, but mainly used by the GeoServer & gvSIG CE projects (web and desktop open source GIS) which provided complex rendering use cases and user feedbacks.

Thanks to my participation to FOSDEM 2015, I discussed with the OpenJDK community how to contribute the Marlin renderer back. I joined the graphics-rasterizer project in march 2015 to contribute Marlin as a new standalone renderer for OpenJDK9. I worked hard with Jim Graham & Phil Race (java2d team) and we proposed the JEP 265: Marlin Graphics Renderer in July 2015. It is now integrated and that intensive work made Marlin even faster !

In this session, you will learn how Marlin works (java2d pipeline, AA algorithm, tuning & benchmark results), how to use it, what performance optimizations were made and of course, my feedback on contributing to OpenJDK. Of course, I will also make a demo comparing OpenJDK Pisces vs Marlin on intensive rendering tasks (based on MapBench).

Finally I would really like to get people helping me to implement new algorithms (clipping, more precise pixel coverage computation, efficient gamma correction) or just try Marlin with their applications to gather more user feedbacks.

Consider the organization of parallel heterogeneous computations. The sequential version runs in two stages: the first stage produces jobs that can be computed independently from each other in the second stage. The producer in the first stage is executed by one task, while the other tasks compute the jobs from the second stage, as the jobs are managed by a queue, implemented by a thread safe package.

This design will be illustrated with an application that involves the refactoring of code in the free and open source package PHCpack, a package to solve polynomial systems by polynomial homotopy continuation.

In this talk, we will see an intro and status of two projects: PyPy, an alternative Python-in-Python implementation; and CFFI, an alternative to using the standard C API to extend Python. These two projects are very different, but CFFI is a possible solution to a problem that hits notably PyPy --- the CPython C API.

The CPython C API was great and contributed to the present-day success of Python, together with tools built on top of it like Cython and SWIG. I will argue that it may be time to look beyond it.

We will see an intro and status of these two projects (the speaker is involved in both):

PyPy: http://pypy.org/

CFFI: http://cffi.readthedocs.org/

PyPy is an alternative Python implementation. It features a JIT compiler that gives important speed-ups over CPython, for almost any program that runs for any amount of time (at least some seconds).

One of the main issues with PyPy is its forever-alpha-status "cpyext" module. It is the part that loads and executes CPython extension modules --- and occasionally segfaults if the stars are not correctly aligned. The C API is very large, exposes the most obscure implementation details, and assumes a memory model (reference counting) that is often different in non-CPython implementations of Python. Thus "cpyext" is the best-effort solution available for PyPy, but is a hack. (IronPython has a similar capability.)

This was partly the motivation for developing CFFI: it is a minimal layer that allows direct access to C from Python, with no fixed intermediate C API. It is available for CPython and for PyPy and could be ported to more implementations. It shares ideas from Cython, ctypes, and LuaJIT's ffi, but the non-dependence on any fixed C API is a central point. Some high-visibility projects like Cryptography have switched to it.

Firefox has recently gained an API designed to let developers and add-on developers monitor in real-time the performance of add-ons, webpages or Firefox itself. In this talk, I will present this API, and what we did to make it work reliably and without reducing the performance of Firefox.

Several years ago, Facebook launched an internal initiative to integrate more encryption into its corporate infrastructure. The effort required advanced, yet highly responsive solutions in multiple areas, including vulnerability management, secure key distribution, and support for dated encryption in markets where modern encryption is still not viable. This technical talk will outline how Facebook has implemented some of these systems and provide recommendations for methodologies and open-source tools that could allow other organizations to put them into practice. It will also discuss how Facebook is addressing the challenge of serving SSL to millions of people in developing countries.

This talk will cover both technical and organisational topics. Main focuses include:

• Designing a software/infrastructure ecosystem that can quickly respond to SSL security issues/other changes
• Handling alerting and certificate monitoring, and where in your SSL stack to put such logic
• Being able to provide both utility and maximum possible security in developing countries
• Things to consider to avoid leaks with new developments in modern SSL infrastructure (for example, Certificate Transparency)
• Proactively monitoring potentially malicious new certificate issuances for your domains
• How we have implemented some of these systems at Facebook, with suggestions for open-source tools to help you do the same if you wish

MediaConch is a project built upon MediaInfo that develops tools to test the conformance of audiovisual files to their associated specifications, to evaluate files against declared policies and to fix metadata in audiovisual files. MediaConch currently focuses on the formats of Matroska, FFV1, and LPCM as implemented by the audiovisual archiving community. Jérôme will present on the process and challenges in creating these tools, address the role of conformance in open media projects, and demonstrate the utility of the project and its components to other open media projects. Jérôme will also provide an update on the IETF working group focused on standardizing web video, including the FFV1 codec and Matroska wrapper.

MediaConch is an extensible, open source software project consisting of an implementation checker, policy checker, reporter, and fixer that targets preservation-level audiovisual files (specifically Matroska, LPCM and FFV1 for use in archives, providing detailed and batch-level conformance checking via an adaptable and flexible application program interface accessible by the command line, a graphical user interface, or a web-based shell. MediaConch is currently being developed by the MediaArea team, notable for the creation of open source media checker software, MediaInfo. Furthermore, the MediaArea team is dedicated to the further development of the standardization of the Matroska and FFV1 formats to ensure their longevity as a recommended digital preservation file format.

4 years ago, the UK set up Government Digital services. The objective was to build "digital by default" government services for the UK public which were "simpler, clearer and faster".

User research, user centred design and open source technologies are central to building services that meet GDS's standards.

This session will be an overview of some projects I've worked on showing how user research and design is done in the open, and will discuss limitations of the government "open source" approach.

4 years ago, the UK set up Government Digital services. The objective was to build "digital by default" government services for the UK public which were "simpler, clearer and faster".

User research, user centred design and open source technologies are central to building services that meet GDS's standards.

Right now the if a member of the public has some research or design input, they themselves are unable to commit a change to it, it's not possible for them to get their "patches" seen, or it is very rare. Why is this?

This session will be an overview of some projects I've worked on showing how user research and design is done in the open, how we try to open source our work where possible, and why we don't when it is not possible.

The session will ask the following questions:

• Is this really open source?

• How could that be improved?

• Does it matter?

IoT.js is a platform for IoT applications written in JavaScript. With IoT.js developers can create IoT services that communicate with each other and the outside world. IoT.js is a lightweight version of Node.js and designed to bring the success of Node.js to small IoT devices like lamps, thermometers, switches and sensors. This class of devices tends to use resource-constrained microcontrollers which are too small to fit a full Node.js stack. In order to meet those constraints, IoT.js runs on top of JerryScript which is a lightweight JavaScript engine running on platforms with less than 64KB of RAM and less than 200KB of flash memory. Despite the low footprint, JerryScript is a full-featured JavaScript engine implementing the entire ECMAScript 5.1 standard. Both IoT.js and JerryScript are open source projects released under the Apache License. The talk will include a demo running a Node.js module with IoT.js on a resource-constrained microcontroller.

The idea is to build a cluster of containers which will be managed by Kubernetes. We will test the fault tolerance of the containers supervised by Kubernetes.

The lab/workshop will introduce the Kubernetes project and its importance. Many of us have started running containers in production or production like environments but the tooling to make it fault tolerant is still not very clear. With this lab, the idea is to start with introducing basic concepts of Kubernetes like pod and replication controller and in what situations they can be used. We will create a pod and a replication controller spec and run it using Kubernetes to run a container based setup. We will kill the container manually to observe how Kubernetes react to such situation. Project link: http://kubernetes.io

The Crazyflie 2.0 is the second generation of the Crazyflie nano quadcopter, a flying open source development platform invented by Bitcraze. Apart from improved hardware and payload it features a modular design (similar to Arduino shields) which adds new capabilities like a LED-ring, wireless charging, a camera, GPS or a prototype expansion board. This allows to do hardware and software development on an open platform that fits in the palm of your hand. The Crazyflie is running on open source software and hardware. It has been used in different private and academic science and research projects around the world.

This talk will focus on the Crazyflie 2.0's modular design (similar to Arduino), new expansion boards (called "decks"), some interesting research projects where it was used and recent improvements on the software side (e.g. flashing the firmware from a mobile device).

Discuss the initial work to integrate PostgreSQL with LibreOffice, and the new installer, recent changes and future plans.

Discuss the initial work to integrate PostgreSQL with LibreOffice, and the new installer 2UDA aimed at data analysts. Also discussion of recent changes and future plans.

Jobs in Jenkins (or any other CI/CD tool) can be created and updated manually using GUI. It is ok if you have a few/several of them. However, most of the companies grow and you can quickly wake up with dozens or hundreds of jobs to maintain.

A new email address/alias to get notification about failed builds? Global migration to the better™ SCM? No way to do it manually with GUI in a convenient way. It just doesn’t scale. Manual scripts using Jenkins API? Better, but hard to test and maintain. The same applies to plugin installation, credentials managements etc. Luckily, there is a better way.

During the talk we will present how Jenkins Job DSL together with Ansible can be used to automatically provision Jenkins instance and maintain any number of jobs. We will show how to define jobs and views in Groovy based DSL and test automatically that the generated structures are exactly the same as expected in Jenkins. Expect live demo - we will setup fully functional Jenkins instance with just one click!

Many companies and individuals have already deployed large SIP networks with tons of endpoints. With WebRTC becomeming so ubiquitous, it makes sense to adapt for these new types of devices.

In 2012 SylkServer (http://sylkserver.com) allowed for seamless SIP to XMPP interoperability, now we are adding WebRTC as a first class citizen. Using SIP as the core routing and rendezvous protocol and either SIP, XMPP or WebRTC at the edges we can reuse existing SIP insfrastructure with the right gateway in place.

Arabesque provides an elegant solution to the difficult problem of Graph Mining that lets a user easily express graph mining algorithms and efficiently distribute the computation.

Distributed data processing platforms such as MapReduce and Pregel (Giraph, GraphLab, Graph-X) have substantially simplified the design and deployment of certain classes of distributed graph analytics algorithms such as computing Pagerank, SSP, CC etc.

However, these platforms do not represent a good match for graph mining problems, as for example finding frequent subgraphs(FSM) in a labeled graph or finding Cliques. Given an input graph, these problems require exploring a very large number of subgraphs (embeddings) and finding patterns that match some “interestingness” criteria desired by the user. The number of the embeddings that the system needs to explore grows exponential to the size of the embeddings. For instance even for a tiny graph of ~4000 vertices, we can reach 1.7 Billion embeddings when we consider embeddings of size 6.

In this talk, we present Arabesque the first distributed data processing platform for implementing graph mining algorithms. Arabesque automates the process of exploring a very large number of embeddings and defines a high-level computational model, Think Like an Embedding (TLE), which simplifies the development of scalable graph mining algorithms. Arabesque based applications require a handful of lines of code, scale to trillions of embeddings, and represent in some cases the first available distributed solutions. Arabesque runs on top of Giraph/Hadoop, but uses the TLE programming model instead of the TLV model.

Virtualization management requires processing continuous streams of data, mostly for monitoring purposes. It is therefore challenging to make sure the different services are able to act properly, rather than become overloaded with incoming data. "Reactive" concepts can help overcome such challenges. In this presentation I'll show how oVirt embraced these concepts and evolved to Reactive architecture, and show the impact it had on overall system performance and stability.

During the process of refactoring how oVirt processes data we have been learning what it is required to change model from proactive to reactive. I want to share our successes and failures during the process because we are/were heavily constrained by backward compatibility. People thinking about performing similar changes would benefit by learning from mistakes that we made.

The Hurd recently saw some experimental work to add sound support. This was done thanks to the Rump kernel, embedded in a library. As a first-working implementation the library is directly linked into mplayer, but of course we plan to make this much more flexible by moving the Rump sound driver into a separate translator, very much like we did for network drivers with netdde. This however poses design questions. The other hardware bit missing on the Hurd is USB support, which we should be able to add a similar way. This poses yet more design questions, as to the shape of the hird of translators we should start for this. This will of course also be the opportunity to give the now-traditional yearly latest news about the Hurd.

The nature of MySQL replication implies various crash scenarios of varying availability impact. Orchestrator is an open source project that discovers, manages and recovers your MySQL replication. Attend this talk to learn how Orchestrator detects failures with minimal false positives/negatives, and figures out the best method of recovery even in complex topologies.

The nature of MySQL replication implies various crash scenarios of varying availability impact. Orchestrator is an open source project that discovers, manages and recovers your MySQL replication. Attend this talk to learn how Orchestrator detects failures with minimal false positives/negatives, and figures out the best method of recovery even in complex topologies.

H2O: An Open-Source Platform for Machine Learning and Big Data/Big Math. H2O is clustering: from just your laptop to 100's of nodes, you get a Single System Image; allowing easy aggregation of all the memory and all the cores, and a simple coding style that scales wide at in-memory speeds.

This is a technical talk on the insides of H2O, specifically focusing on the Single-System-Image aspect: how we write single-threaded code, and have H2O auto-parallelize and auto-scale-out to 100's of nodes and 1000's of cores.

H2O: An Open-Source Platform for Machine Learning and Big Data/Big Math. H2O is clustering: from just your laptop to 100's of nodes, you get a Single System Image; allowing easy aggregation of all the memory and all the cores, and a simple coding style that scales wide at in-memory speeds. H2O is easily 1000x faster than disk based clustering solutions, and often 10x faster than best-of-breed alternative in-memory solutions. H2O is Big Data: we ingest a wide variety of formats, in parallel and distributed across the cluster, and store the data column-compressed - often exceeding 2x to 4x gzip-on-disk. H2O is Big Math: we do scale-out math at memory-bandwidth speeds (on compressed data!), making terabyte-scale munging an interactive experience. H2O is Machine Learning: On this Big Data, Big Math platform we have Best-of-Breed implementations of effective and popular Machine Learning algorithms: e.g. Deep Learning (Neural Nets), GBM, Random Forest, GLM, K-means, PCA, Naive Bayes, and more... with all the features you need to do real data science built-in. Finally H2O interacts directly with Python, R, Scala, Spark, REST/JSON, and a JS-based web browser - making it the most interconnected Machine Learning platform out there.

This is a technical talk on the insides of H2O, specifically focusing on the Single-System-Image aspect: how we write single-threaded code, and have H2O auto-parallelize and auto-scale-out to 100's of nodes and 1000's of cores.

Rspamd is fast open source (BSD licensed) spam filtering system that uses score system to filter messages. In this presentation, I will speak about the internal architecture, performance optimizations, security issues, algorithms used and general spam filtering problems.

In this presentation, I will describe rspamd - a fast spam filtering system used by many companies that process large volumes of e-mail. I'll demonstrate performance comparison graphs, algorithms and rspamd's internal architecture. The overall talk will consist of 4 components:

• Introduction to spam filtering:

  • What are the most popular spam types so far: advertising, fraud, cloaked spam, images spam
  • What techniques are mainly used to fight spam: adaptive filtering and machine learning, patterns matching, black and white lists
  • Why is it so difficult to write a good spam filtering system: spam for one person could be a useful message for another
  • What is wrong with spam: ethical and security considerations

• Architecture description:

  • What makes rspamd different from other state of the art spam filters: internal architecture, plugins and rules
  • Which algorithms are optimal to fight spam: OSB Bayes, shingles for fuzzy hashes

• Performance optimizations used:

  • How to write a spam filter that can filter hundreds of messages per second on commodity hardware: event based architecture
  • Global and local optimizations used: abstract syntax tree optimizations, branches cut, greedy optimizations
  • Why the standard approaches are broken: zero terminated strings, many POSIX functions
  • Other high performance technologies: hyperscan, pcre jit, aho-corasic tries, radix tries, lua-jit

• Security discussion:

  • Why encryption is important for all traffic in the network
  • Why email security is absolutely essential at all stages
  • What makes TLS not so easy to introduce in a datacentre: latency issues, hard to use with events, complicated model of trust

In conclusion, this talk describes a lot of state-of-the-art methods of spam filtering and other topics, such as writing high performance systems and security in email processing systems.

The United States Supreme Court's ruling in the landmark Alice vs. CLS Bank case has finally given the lower courts some tools to overturn vague and poorly written software patents. Larger companies may see fewer lawsuits in the short-term, but we're far from finished. Smaller companies are still at risk and bad actors could use international trade agreements to stop or roll-back recent gains.

The last year's been very interesting for those of us who have been looking on in horror over the last decade as billions of dollars was spent on frivolous and ridiculously broad software patent litigation. The United States Supreme Court's ruling in the landmark Alice vs. CLS Bank case has finally given the lower courts some tools they could use to overturn obvious and vague patents. Many judges have found for the defendant and overturned obvious patents. For entities with the time and money to fight bad patents in court, this is fantastic news. As many as four out of five of the software patents on the books in the US might be found invalid under the new doctrines. For everyone else, this is a mixed bag.

There are still several things we need to pay attention to. Patent suits can still be brought. For entities that can't afford to fight, those disputes will be settled out of court -- without the full impact of the court's updated scope of patentability. Without legislation, it will take twenty years to cycle out the old style of broadly written patents. So, even if the United States Patent and Trade Office fixes their processes immediately we will still have a very long tail to contend with. The new scope of patentability hasn't been fully tested and there may yet turn out to be gaping loopholes that bad actors may use to undo the progress that has been made. Finally, global entities may use international trade agreements to stop or roll-back the progress made against poorly conceived patents in any country that has signed a sweeping treaty with patent language.

In short, we aren't done yet. The best way to keep moving forward is for the global community to work together. This talk is for anyone who is wondering what the recent decisions mean for small and mid-size entities, how international treaties can impact local policy and what can be done to improve the situation.

Openconnect is a relatively new VPN solution. It started as a client for CISCO's anyconnect VPN server, but it has now surpassed that role and provides a reliable VPN solution with a very conservative security architecture for the server. This talk will go through the story behind the development of the OpenConnect VPN server, address the question on the need for a new VPN solution and feature the distinctive security features and capabilities of openconnect. Finally we will provide an insight on the current development plans.

Openconnect is a relatively new VPN solution. It started as a client for CISCO's anyconnect VPN server, but it has now surpassed that role and provides a reliable VPN solution with a very conservative security architecture for the server. This talk will go through the story behind the development of the OpenConnect VPN server, address the question on the need for a new VPN solution and feature the distinctive security features and capabilities of openconnect. Finally we will provide an insight on the current development plans.

The Python language is hard to optimize. Let's see how guards checked at runtime allows to implement new optimizations without breaking the Python semantic.

(Almost) everything in Python is mutable which makes Python a language very difficult to optimize. Most optimizations rely on assumptions, for example that builtin functions are not replaced. Optimizing Python requires a trigger to disable optimization when an assumption is no more true. FAT Python exactly does that with guards checked at runtime. For example, an optimization relying on the builtin len() function is disabled when the function is replaced.

Guards allows to implement various optimizations. Examples: loop unrolling (duplicate the loop body), constant folding (propagates constants), copy builtins to constants, remove unused local variables, etc.

FAT Python implements guards and an optimizer rewriting the Abstract Syntax Tree (AST). The optimizer is implemented in Python so it's easy to enhance it and implement new optimizations.

FAT Python uses a static optimizer, it is less powerful than a JIT compiler like PyPy with tracing, but it was written to be integrated into CPython.

Light virtualisation is often viewed as a security mechanism providing isolation on a production device or as a quick deployment tool for Cloud services. But it can also be used in automotive projects as a tool to ease the development phase. This talk focuses on Docker benefits for the whole development cycle of an automotive project: it can increase build speeds and allows easier sharing of common snapshots between developers. Platform and application developments can also benefit from containers at various stages. Long term support is equally made easier.

This talk focuses on Docker usages in AGL project and will demonstrate: * how to use containers to increase snapshots build speed * how to share a reference environment amongst developers * how to create a binary distribution for platform and application development * how to get ubiquity: development on the cloud, on-premises, on a single laptop * how to run some QA tasks more easily * how to use containers for long term support

Upipe is a recent project, designed to build custom multimedia players, transcoders or streamers. The presenter will explain how the use of Upipe in OpenHeadend products enabled them with advanced video processing capabilities, and will highlight the features that make Upipe so adapted to these use cases.

Upipe is a flexible dataflow framework. 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 include examples of complex pipelines performing video processing, and detail the unique features of Upipe that make the lives of developers easier.

Workshop Presenters will be Johan Lorenzo and Martijn Wargers of the Firefox OS QA Team.

Description: What is covered? * Types of tests (integration, end-to-end running on device) * Continuous integration and reporting system (Taskcluster and Treeherder) * Setting up your working environment (Marionette, MarionetteJS, Node) * How to run existing tests on desktop and on device * Creating a new UI test

Workshop Presenters will be Johan Lorenzo and Martijn Wargers of the Firefox OS QA Team.

Description: What is covered? * Types of tests (integration, end-to-end running on device) * Continuous integration and reporting system (Taskcluster and Treeherder) * Setting up your working environment (Marionette, MarionetteJS, Node) * How to run existing tests on desktop and on device * Creating a new UI test

Thermostat has evolved a log way from being a specialised tool for performance monitoring and analysis of the JVM, first by encompassing a generic framework for performance analysis and data visualisation and now with the addition of a powerful and advanced new Platform infrastructure that also allow users to build completely standalone projects.

The Platform offers a familiar environment that handles Model View and Controllers objects, presentation layer, threading models, visualisation and also special effects, and a new data architecture.

In this presentation we will demonstrate how to build an application based on Thermostat in few simple steps and how to take advantage of the new architecture to build stunning and visually appealing applications.

In this talk, I will tell you how and why OpenEmbedded embraced user-centered design, explain our design process, and show how design can make important contributions in the most unlikely places.

OpenEmbedded is an embedded Linux build system, a wickedly complicated tool for engineers to create heavily customised Linux distributions for small computers. OpenEmbedded tools have always been text-based: their users are masters of the command line, and have trained their brains to extract knowledge from large blobs of raw text data. How did an interaction designer end up becoming an OpenEmbedded contributor?

In this talk, I will tell you how and why OpenEmbedded embraced user-centered design, explain our design process, and show how design can make important contributions in the most unlikely places.

Elasticsearch is a distributed and scalable data platform written in Java that, besides the transport protocol (Java to Java), offers a very complete REST API accessed through JSON. This talk will cover the details of the Elasticsearch client we built for Lua as a part of the GSoC program in the LabLua organization.

By using the elasticsearch-lua client a programmer can access most Elasticsearch functionalities and benefit from: proper load balancing across all nodes with pluggable and multiple selection strategies; a connection pool; and the reindex feature (not available in Elasticsearch).

We will also show how this client could be used to implement a search feature in a website that is based on a SQL database, and how can we use the data in Elasticsearch to also perform fast analytics.

This talk will present a prototype for crash reporting in LibreOffice. The talk will show the client and server components and include a live demo of the Linux client and the server.

Programming a Board game? Why would you want to do that?

In this lightening talk I will take as few turns as possible to explain why and how I decided to program a board game. Yes, a physical, printed board game.

We will look at wondrous technologies such as Markdown, Pandoc, LaTeX and chaining them all together to create a multi-format generating workflow and (hopefully) win.

The Eurocontrol Flow Management System provides a simulation functionality to evaluate air traffic flow management measures (such as delay assignments or reroutings) before applying them operationally. This implies to upload a day worth of traffic in a simulation environment.

This talk will describe various techniques and tools used to optimize the simulation startup time, and will discuss the gains reached via micro-optimization (among others using Valgrind) or via macro-optimization (such as using parallelism features of Ada).

Usually IoT discussions focus either on the hardware for setting up the sensors and bridging devices or in the middleware for dealing with the data aggregation from the sensors. This misses the point that IoT is the realization of end-to-end machine interaction. In this talk I address this issue by showing how to approach IoT end-to-end using free software. We'll pick and choose from many projects out there, some of them apparently unrelated to more "traditional" IoT approaches are revealed to be fundamental for a scalable IoT implementation.

Usually IoT discussions focus either on the hardware for setting up the sensors and bridging devices or in the middleware for dealing with the data aggregation from the sensors. This misses the point that IoT is the realization of end-to-end machine interaction. In this talk I address this issue by showing how to approach IoT end-to-end using free software. We'll pick and choose from many projects out there, some of them apparently unrelated to more "traditional" IoT approaches are revealed to be fundamental for a scalable IoT implementation.

Matrix is an open standard for open decentralised real-time communication using simple HTTP APIs and WebRTC, providing fully decentralised communication history with cryptographic integrity and no single point of control over any given conversation. Since our debut at FOSDEM 2015, the project has grown significantly as we've added end-to-end encryption, glossy clients, read receipts, WebRTC conferencing, and built bridges and integrations with a huge range of existing communication networks. This talk discusses the challenges we've hit along the way, and updates the FOSDEM community on how our mission is progressing!

Today, most commonly used VoIP and instant messaging apps do not interoperate, and all your data is stored in each service, locking in users and fragmenting their conversations and contacts between different vendors. In the Matrix ecosystem, anyone can run a server (called a "homeserver"), and a communication room is owned by all the homeservers participating in that room.

Users can communicate via any client or service that understands the Matrix protocol; we provide open source implementations for web and mobile, and members of the community have written many other open source clients in languages ranging from QML to Emacs. We have also written bridges that enables a homeserver to connect to existing protocols such as IRC, XMPP or SIP, and solutions such as FreeSWITCH, Asterisk and even Lync.

In this session we will explain the design choices we made when creating Matrix, the challenges over the last year, and we will look at different clients and servers that have been implemented (both by ourselves and the community). We'll demo the latest features such as end-to-end encryption and video conferencing, and show how Matrix is a viable option for all your open realtime communication needs!

I'll give a brief overview of how we're (LXD) planning to (or hopefully by FOSDEM actually) using p.haul.

Minix-vmd is a fork of MINIX 1.6 developed by Kees Bot and Philip Homburg. The goal of Minix-vmd was to go where MINIX could not go. MINIX was to remain simple enough for students to understand. Features such as virtual memory, job control, virtual filesystems, etc. where out of scope. Minix-vmd was created to see what MINIX would look like with those features.

In this talk I will go over the history of Minix-vmd, highlighting features that sometimes made it into MINIX2, in some cases to be dropped again from MINIX3. Features that never made into any other MINIX version. Features that might be too radical.

I will also briefly touch upon the importance of eating your own dog food. Taking an experimental system into production elevates it beyond that of a toy system. Minix-vmd has been in various forms for production use for over two decades. For me personally, Minix-vmd is my main internet router for the last 15 years, handles my e-mail, usenet, backups, DNS for my domain, and ntp.

In this talk I intend to demonstrate how we had integrated the Java virtual machine into a multi-threaded, pluginized C program. If you have ever encountered the problem that something only has Java API while you intend to use it with your C / C++ code, this talk is for you.

The goal of syslog-ng is to become a major player in the big data logging infrastructure market. Our aim is to be the fastest and most reliable logging software that can send messages to most big data tools, for example Elasticsearch, Hadoop and Kafka. Most big data software uses Java API. Originally, syslog-ng has been written in C, with the pros and cons of the language. Although there are a few 3rd party tools in C language, utilizing these results in encountering several problems, for example difficulties when we attempt to follow the original libraries, maintenance issues, and so on. Therefore, in order to stay up-to-date with the big data tools, we must use the official Java APIs. This is why we have started our “Java language binding” project. We also hope that this project will be an important factor in the syslog-ng community, because now anyone who wants to contribute to improving syslog-ng by developing plugins in Java can do so.

MySQL introduced PERFORMANCESCHEMA in v5.5. In v5.6 it became useful and interesting. Later the SYS Schema was added to make it easier to use the PS. In this presentation we will have a short look how you enable PS, how you configure it and what you can get out of the PS with and without the SYS Schema.

MySQL introduced PERFORMANCESCHEMA in v5.5. In v5.6 it became useful and interesting. Later the SYS Schema was added to make it easier to use the PS. In this presentation we will have a short look how you enable PS, how you configure it and what you can get out of the PS with and without the SYS Schema.

Continuous Integration with Lua? Is it worth it? Is there at least a modern way to do it?

I have implemented some reasonably popular open-source Lua libraries, like middleclass.lua & inspect.lua. I would like to share how I make my life easier with automatic testing & automation.

On this talk I will:

• Briefly talk about why & how to do automated tests in Lua
• Exemplify my current method of configuring travis+github in an opensource project
• Talk about other options & alternatives

This application is aiming at providing terrestrial broadcasting signal (TV), on any mobile device by using a wireless network. It makes use of an existing standard (SAT>IP) to make the server visible and discovered by existing clients (Applications) running on Android or iOS.

This application is aiming at providing terrestrial broadcasting signal (TV), on any mobile device by using a wireless network. The proof of concept has been demonstrated, by developing a solution (server) based on an open source software, from which everyone can benefit and which runs on different operating systems (Linux, Windows) and hardware platforms (PC, Raspberry PI, Synology NAS). It makes use of an existing standard (SAT>IP) to make the server visible and discovered by existing clients (Applications) running on Android or iOS.

In modern virtualization platforms virtual machine disks are stored in various kinds of shared repositories which are accessed by thousands of hypervisors simultaneously. Changes are constant. How can you provide high performance access to these resources while ensuring a consistent view of the world across all systems? When bad things happen, how do you restore the integrity of the data?

This talk will share an approach being taken by the oVirt virtualization platform to address these challenging storage problems. Complex storage tasks are broken down into simpler metadata and datapath operations. A set of rules for handling each type will be established. Through several examples, the audience will learn how a combination of SAN-based locking, atomic commitment, and garbage collection can help to achieve a high performance, fault-tolerant storage architecture.

BMUnit is the package which integrates Byteman into JUnit and TestNG, enabling you to locally redefine the behaviour of application or JDK runtime code for the duration of a single test or group of related tests. BMUnit is very simple to use; just add a few annotations to your test classes and place a few jars in your classpath. This talk will explain how BMUnit works by presenting and executing tests which exemplify the 3 most common use cases:

• injecting trace code so you can be sure your tests enter the expected code paths

• injecting validation rules so you can assert that specific outcomes do occur

• injecting 'faults' to modify state or control flow, driving the application or JDK runtime down the path needed to exercise a desired test scenario

(Please note that this talk replaces 'Displaying Application Events in Thermostat Using Byteman')

A brief discussion about the stable release branch 4 of KiCad as well as goals for the next development cycle and beyond.

Teams working across disciplines often suffer from misunderstandings, which creates tension. Let’s look at ways we can better understand each other to create products that users love.

What do designers do? What can they bring to a project, and when should you bring them in? Designers and developers don’t always have the easiest working relationship. But working together, we can make awesome products and services. How can we work together to produce work everyone is proud of? Which project set-ups work best and which tools can we use to help each other? In the end, it’s our users who will win.

Users (and developers) don't just want to run an executable, they also like to know that it runs efficiently, that it doesn't use unnecessary resources and if it crashes and burns they want to collect the pieces and inspect what went wrong. So a package should also provide the user with a means to easily profile, trace and debug what is running on their system. This means a distro should also package symbols, debuginfo and sources for easy/automatic installation. With different distros and different versions of distro packages running next to each other in containers we need some standard conventions to identify executables (build-id) and match and fetch the needed symbols, debuginfo and sources to help the user profile, trace and debug any binary they find on their system.

We will go briefly over differently tools for shared library abi inspection, tracing, debugging, profiling and post-mortem crash analysis. What extra information such tools need, like CFI/backtrace, symbols, gnu_debugdata, debuginfo and sources. Then we will discuss the tools that are used on Fedora to extract and package the extra information. How build-ids are used as a means to find/match the information. So the user/developer can know exactly which version of a library was actually running when the core file was created for example. And identify some deficiencies in the current packaging. It is impossible to install both the 32bit and 64bit version of the debuginfo for example. What extra challenges there are when you might be running different versions of a package in different containers. And some suggestions on tools and conventions that distro packages can adopt to make all this easier for the user and tools. At the end it would be nice to have a discussion how other distros deal with some of these challenges. How distros/packagers can coordinate on making this information (a symbol/debuginfo server) available cross distros and how/if to extend these ideas to non-native ELF/DWARF executables.

Lepton/Tauon is an open source POSIX "compliant" operating system (OS) for deeply embedded devices. It tries to bring PSE-53 POSIX capabilities to emdedded world.

Lepton is an POSIX operation system that targets deeply embedded system and platform like cortex-M. Lightweight is greek translation of lepton. It brings modularity and "application" process development for limited resources system (few hundred of Kio FLASH and few dozens of Kio RAM).

The aim of this project is not to develop an another operating system like GNU/Linux but an human undestandable OS that provides more services than a realtime kernel, while keeeping a reasonable footprint for deeply embedded system.

Lepton eases portability of UNIX-like programs and libraries with providing a POSIX layer that gives application programer most common syscalls like vfork and exec.

Lepton is not only a POSIX layer, it takes some concepts from UNIX "philosophy": - Modularity and reusability - Everything is file. Everything is a stream of bytes. - Standard input/output

In fact more than 150 functions of POSIX standard are available for : - process and thread creation/synchronisation - standard peripherals abstraction layer like Linux kernel modules - UNIX stream mechanism. - network support though LWIP or uIP from contiki. - VFS virtual file system layer to add any type of file system (FAT, YAFFS ...). - gui libraries (nanoX and FLNX) - network standard services like webserver and FTP server

Lepton is already use in industrial products like oscilloscopes and electrical installation testers.

Some demonstrations will be showed with AT91SAMD20 (cortex-M0+) and STM32-nucleo (cortex-M4).

The open-source software plays a vital role in our worldwide computing infrastructure. When vulnerabilities are discovered in our software, our response can have a major impact on how much risk our end users are exposed to.

The XenProject's security response process has been hardened and tested over years of experience, and has weathered several storms. This talk will share some war stories from our security response process that explain how we got to where it is today, so that you can learn the easy way, from our experience, rather than the hard way, from your own experience.

This talk will briefly cover the history of response processes -- from non-disclosure to full disclosure to coordinated or "responsible" disclosure, and pre-disclosure.

We'll then cover two major events -- XSA-7, the Intel SYSRET vulnerability; and XSA-108 -- that highlighted some weaknesses in our process, and how we tweaked the process in response.

Finally, we'll cover how we handled the a very controversial community discussion after XSA-7 in a way which, we hope, gave everyone in the community an opportunity to have their voice heard and counted, in spite of the complete lack of consensus.

Libct is new Odin's library for creating and managing containers. Its main goal is to simplify usage of container functionality for applications. This library allows to create isolated environments and control groups. Your applications now may use the full power of Linux container virtualization with libct.

June, 2015: a raceway in California hosts the biggest real size humanoid robot competition in history with 26 teams from all over the world. It was the Darpa Robotics Challenge. The goal of the contest was to push the limits in robotics to assisting humans in responding to natural and man-made disasters. Two years before, as the first part of the contest, took place the Virtual Robotics Challenge (VRC) which consisted on replicate the same set of tasks proposed in challenge finals but using cloud-based robotic simulation instead of real robots.

The Open Source Robotics Foundation (OSRF), thanks to its open source robotics simulator Gazebo and the ROS (robot operative system) framework, was selected to rule this virtual contest. It was a challenge to manage the software infrastructure, from the simulator to machine provisioning, and testing played a key role. The talk will review the testing practices that were designed and implemented during the development of the software infrastructure used for the Virtual Robotics Challenge.

How was the testing of a robotics contest in the cloud done? What did we learn about testing software from organizing the VRC? How using open source software helped to organize the VRC?

The talk will review the testing practices that were designed and implemented during the development of the software infrastructure used for the Virtual Robotics Challenge. The scope of the techniques applied goes from automated testing of VRC software pieces (Gazebo simulator, DRCSim - DRC specific ROS wrappers and materials and the Cloudsim web provisioning tool) to the manual testing plan. Interesting points to explore in the talk:

• The root of all testing done: our continuous testing integration (CI) setup. Jenkins, and how GPU testing is done on it for different platforms.
• The importance of moving continuous testing integration to run as soon as possible in production machines (real challenge machines).
• How different cloud providers were tested and when and how the problems appeared. Experience here is nice to know since problems were not trivial.
• How the “release often, release early” philosophy was applied during the development cycle to keep users in the testing loop. How nightly builds played a fundamental role in this.
• How the ideal testing does not exists and how can real production tests with real users be the best of your test suites. How was that scheduled in VRC.
• How exceptional cases, like identifying an exploit hours before the competition, were managed to not affect the testing done before.

The goal would be to provide the audience with feedback and conclusions about software testing and testing decisions in a real big open source robotics software event from first hand.

Despite its maturity and popularity, the C programming language still lacks tool support for reliably performing even simple refactoring, browsing, or analysis operations. This is primarily due to identifier scope complications introduced by the C preprocessor. The CScout refactoring browser analyses complete program families by tagging the original identifiers with their precise location and classifying them into equivalence classes orthogonal to the C language's namespace and scope extents. A web-based user interface provides programmers with an intuitive source code analysis and navigation front-end, while an SQL-based backend allows more complex source code analysis and manipulation. CScout has been successfully applied to many medium and large open source and proprietary projects identifying thousands of modest refactoring opportunities. Projects where CScout has been applied include the Linux, FreeBSD, and Solaris kernels, Apache httpd, awk, PostgreSQL, and gdb.

Docker and MySQL are two mainstream technologies that are reshaping the IT environment and the web economy. While using MySQL is reasonably straightforward, using it in Docker may prove challenging. This talk will show the main points of Docker operations with plenty of easy-to-follow examples, including MySQL in replication using containers.

Running database operations in containers is a slightly different proposition than running other services. MySQL, being designed - as the majority of services - for running in a dedicated host, needs some adjusting to fit in a container. Thanks to its configurability, we can deploy many MySQL containers to fit our purposes, with just the right amount of customization. However, customizing MySQL in Docker is not as easy as it would be when you have a full machine at your disposal. This talk will show examples of how to combine MySQL best practices with the ones that apply to containers. The net result will be the deployment of dozens of MySQL instances with little effort.

At the Leipzig University, we develop Gradoop [1], a framework for distributed, declarative graph analytics on top of Apache Flink [2]. Gradoop is designed around the so-called Extended Property Graph Model (EPGM) and supports semantically rich, schema-free graph data. In this model, a database consists of multiple property graphs, which we call logical graphs. These graphs are application specific subsets from shared vertex and edge sets. The EPGM provides operators for both single graphs as well as collections of graphs. Operators may also return single graphs or graph collections thus enabling the definition of analytical workflows in a declarative way.

In my talk, I would like to give an overview of Gradoop, the EPGM and its operators and show how Apache Flink helps us by presenting a subset of our operator implementations. Furthermore, I will sketch the usefulness of Gradoop by presenting an analytical use case from the business intelligence domain.

Gradoop is open-source and licenced under GPLv3. The Gradoop source code and a short documentation can be found on GitHub [3], a more detailed explanation of the data model and our operators can be found in a technical report [4].

[1] http://www.gradoop.com [2] http://flink.apache.org/ [3] https://github.com/dbs-leipzig/gradoop [4] http://arxiv.org/pdf/1506.00548.pdf

Intended audience and goals of the talk

The targeted audience are analysts and/or developers that already have some knowledge about graph systems, e.g. semantically expressive graph database systems like Neo4j or generic graph processing systems like Apache Giraph. The goal is to present our concept of combining those two approaches to allow powerful graph analytics in a distributed way.

Previous talks about Gradoop

Flink Forward, October 2015: http://flink-forward.org/?session=gradoop-scalable-graph-analytics-with-apache-flink

Lua is a very fast and powerful scripting language that can be easily embeddable. It has been shining in industries like game development, for example. Lua is also an excellent tool as a general purpose language and can be used to develop robust applications. Its use in web developments, however, despite its great potential and incredible benchmarks, needs to be more widespread. This talk will mention the current state of Lua in web development, show some benchmarks, compare existing tools and teach developers how to get started with Sailor, an MVC web framework written in Lua.

The stability of a webchat is dependent on numerous factors, ranging from quality of code and browser compatibility, to the stability of the infrastructure and the way it handles network instabilities. To make a sensible comparison between webchats or to measure changes in stability with a new version of a webchat, there needs to be some kind of standardized testing. In this talk I will show how I have set up an automated testing environment that automatically simulates numerous potential problems, including network instability.

Using a real world example, I will discuss in this talk: -Potential sources of instability in webchats -Selecting what tests are relevant -Setting up automated testing of webchats -Testing the behaviour of the webchat on unstable networks -Results and lessons learned

The code used for the testing is available on GitHub: [https://github.com/winfried/WTF] (Webchat Testing Framework)

The USB Armory is an open source computer in the form of a USB stick. It normally runs Linux. But thanks to the ARM TrustZone capabilities of the device, it is possible to run the Genode OS Framework as microhypervisor behind the back of Linux. This is useful for shielding sensitive information like cryptographic keys from Linux by exposing it to Genode only and thereby drastically reducing the attack surface. Even in the event Linux gets compromised, e.g., by a vulnerability in the USB stack, the secrets remain protected.

In the talk, I'll first give a short introduction into the USB Armory project and its motivation. After that, I'll tell the development story of Genode's microhypervisor scenario. I'll also illustrate how the TrustZone technology is used to isolate Genode from Linux without compromising the rich feature set of Linux, and how both worlds can safely communicate with each other. Last but not least, I'll demonstrate the scenario itself and how it can be reproduced.

Flow is a structured discussion system for MediaWiki wikis, including Wikipedia. Development is led by the Collaboration team at the Wikimedia Foundation, and we have gradually begun using it on Wikimedia projects.

LiquidThreads, an older structured discussion system for MediaWiki wikis, is still in use on some Wikimedia wikis.

Both projects aim to foster Wikimedia collaboration.

We have been converting discussions from LiquidThreads to Flow, to reduce technical debt and make Flow's new features and design available to more users. We have implemented resumable batch software to complete this work.

This talk will be a playful, guided walk through Wikimedia's conversion, exploring how batch software for a complex system has been developed, debugged, and (repeatedly) troubleshooted.

Come hear about the batch architecture and the conversion process. Topics will include performance issues with long-running batch jobs and the challenges of mapping between systems with different data models. Plus, hear why a post about broken JavaScript broke our node.js service, what characters are (really) allowed in HTML 5 and XML, why "Ciudad de México" was the last page I converted in Mexico City, and more.

Flow is a structured discussion system for MediaWiki wikis, including Wikipedia. Development is led by the Collaboration team at the Wikimedia Foundation, and we have gradually begun using it on Wikimedia projects. Flow has its own data model and storage for discussions, posts, and revisions.

Unlike other discussion mechanisms on Wikipedia, Flow has a modern user experience. We also plan to extend Flow to support workflows. Workflows would, for example, allow people to use a structured process to discuss elevating an article to “featured” quality.

LiquidThreads, an older structured discussion system for MediaWiki wikis, is still used on some Wikimedia wikis. It uses the standard page- and revision-based storage system. LiquidThreads has a somewhat different feature set from Flow.

Both projects aim to foster Wikimedia collaboration, especially for new users. The Collaboration team has been converting discussions from LiquidThreads to Flow, to reduce technical debt and make Flow's new features and design available to projects that want it. We have implemented resumable batch software to complete this work.

This talk will be a playful, guided walk through Wikimedia's conversion, exploring how batch software for a complex system has been designed, developed, debugged, and (repeatedly) troubleshooted.

Come hear about the batch architecture and the conversion process. I'll briefly explain how the pluggable conversion architecture we developed initially supports converting from LiqudThreads, but could be used to convert from other discussion systems in the future. I'll cover some of the challenges of mapping between systems with different data models. The talk will also explain how we tested against production data locally.

I'll also discuss how we staged such a large conversion, and the ordering of pages we chose. Converting certain pages first allowed us to reduce user impact while bugs were ironed out.

The talk will also consider performance issues with long-running batch jobs, particularly memory leaks.

Plus:

• Why a post about broken JavaScript broke our JavaScript service
• Why a post about broken XML broke our XML parser (and what characters are (really) allowed in HTML 5 and XML)
• Why "Ciudad de México" was the last page I converted in Mexico City.
• Why bash is not the best Unicode toolkit available.
• And more

We all know security is hard. If your originally small open-source project that targeted home-users is suddenly attracting big enterprises with high security requirements as users, it’s probably even harder.

This talk will cover the highlights of the four year long security story of ownCloud (owncloud.org), an open-source file-sync and share solution used by millions of persons world-wide.

A lot has happened in these 4 years. The recent addition of the Bug Bounty program being a notable example.

So let’s reflect: What has potentially gone wrong? What could have been better and was everything we’ve done really a good idea?

We all know security is hard. If your originally small open-source project that targeted home-users is suddenly attracting big enterprises with high security requirements as users, it’s probably even harder.

This talk will cover the highlights of the four year long security story of ownCloud (owncloud.org), an open-source file-sync and share solution used by millions of persons world-wide.

A lot has happened in these 4 years. The recent addition of the Bug Bounty program being a notable example.

So let’s reflect: What has potentially gone wrong? What could have been better and was everything we’ve done really a good idea?

Copyleft has faced serious challenges in the last five years. It's not over: many more threats are on the way. Not by coincidence these attacks on copyleft come when "Open Source" reaches new heights of success. For example, hordes of software developers are funded full time to churn out new Free Software, as long as it's not copylefted. Some such code is specifically designed to replace existing, widely used, copylefted programs. Meanwhile, programs under copyleft licenses (most notably the kernel named Linux) face a decades long, ongoing myriad of license violations. Such violations include nefarious attempts by major companies to shirk their responsibilities under copyleft. The situation is undoubtedly bleak. Those of us who care about software freedom need a plan. Copyleft once assured an equal playing field, but big companies work daily to tilt the playing field in their favor and against the interests of most developers, hobbyists, users, and enthusiasts.

Copyleft, and the GNU General Public License (GPL) in particular, have faced serious challenges in the last five years. It's not over: many more threats are on the way. Not by coincidence these attacks on copyleft come when "Open Source" seems to reach new heights of success. For example, hordes of software developers are funded full time to churn out wonderful new Free Software, but their employers make one key requirement: develop Free Software only under non-copyleft licenses. Some of this new code is specifically designed to replace existing, widely used, copylefted programs and packages. Meanwhile, those programs that remain under copyleft licenses (most notably the kernel named Linux) face a decades long, ongoing myriad of license violations. Such violations, most frighteningly, include nefarious attempts by major companies to shirk their responsibilities under copyleft. The situation is undoubtedly bleak. Those of us who care about software freedom need a plan. Up until now, copyleft assured an equal playing field, but big companies work daily to tilt the playing field in their favor -- directly against the interests of most developers, hobbyists, users, and enthusiasts. This talk will present the political challenges that copyleft continues to face, and offer real actions that individuals can do to assure software freedom for everyone.

Wireless camera rigs like the GoPro Link are expensive and only available to a select few. This presentation explains how we built our own at a fraction of the cost using parts easily available to anyone.

Using a bunch of different Open Source projects and hardware with Open Source firmware it is possible to build your own wireless camera which is comparable to much more expensive alternatives. This talk will explain how we did it, how it works, how we've tested it and how we aim to improve it.

WebIDL is the language used in specification to describe the syntax of an API. Major browsers are not only using it, but are also publishing the WebIDL of what they really implement. This talk will explain the standard language, as well as some Gecko-extensions, in simple terms.

The talk will: - present the syntax of the standard language and how it maps to actual properties and methods in JavaScript. - explain some of the current standard annotations like [SameObject] and [NewObject] - explain some extensions used in Gecko to add more semantic to the file. - inform where to find the actual WebIDL files as implemented by the different rendering engines. - explain how this info is used beyond browser developers, like for documentation purpose.

Don't be afraid of WebIDL anymore!

PCBmodE is an open source PCB design tool written in Python. In practice, PCBmodE is run in commandline to convert JSON files to SVG, extract changes from an edited SVG, and generate Gerbers and drill files from the SVG. Graphical editing is done in Inkscape, though much of the design is defined in the primary JSON files edited in a text editor. It doesn't currently have a notion of schematics or DRC.

We might need a designer to provide a clear vision and solve everything we couldn't agree upon. Also the designer might expect to be warmly welcomed inside Open Source projects, but the reality can be a bit different. We always have expectations on how the designer - community interaction should be, but in order to have a successful collaboration we need compromises, sometimes from the designer's part, other times from the community members.

If we were to ask someone if Open Source communities need designers, the answer would be 'YES'. But do we know what it means to have a designer among us? What will he do? For how long? How true can he stay to his predefined design process? Are all the design stages relevant in Open Source? How open the artefacts he creates need to be? With what type of tools?

We all have an image in our head about the type of designer we need for our community, but how much of that image corresponds to our real needs and with the designer's reality and expectations?

In order to integrate in an Open Source community, a designer might need to revoke his design 'purity' and make some compromises, like doing a bit of development for example. Does working in a free or open environment mean that the work needs to follow the same rules? What is preferred: creativity or consistency? Does the designer have the final decision?

Working in an utopian environment doesn't mean that we don't do compromises. So, how much do we compromise?

We present a live-patching technique based on systemtap's programmable in-situ instrumentation. These patches are limited to modifying data instead of code, but are often sufficient to put a bandage on a bleeding security vulnerability - or even a plain bug.

Some security vulnerabilities can't be patched right away. Maybe the vendor hasn't provided an update; maybe the service can't be restarted; maybe the software is private, abandoned, or unchangeable.

Do not despair! Systemtap, a programmable system introspection tool, is customarily used to trace and profile. But its toolkit includes instruments to poke too - to change state. It turns out that this is enough to work around many vulnerabilities. Since systemtap scripts can be run against a live system, we can protect against exploits without a restart.

We will present a set of approaches and applicability criteria, depending on the nature of the vulnerability and its exploits. Some problems can be surgically corrected; others require killing the process before it turns to crime.

Gluster provides Software Defined Storage for the cloud, and is gaining new functionalities every couple of months. New features make it possible to deploy the cloud storage solution for an increasing number of use-cases.

The Gluster project tries to release a major version every six months. Each version introduces many new features. Use-cases that were not a good fit for Gluster, are getting the improvements so that using Gluster can be considered again. Recently added features include BitRot detection, NFS-Ganesha integration for high-availability NFS access, improved options to prevent split-brain situations and many more. Later in 2016 a major feature release is planned, this will include support for New Style Replication, Distributed Hash Translator v2 and a complete rewrite of the main GlusterD management daemon to make it more scalable.

During the presentation, an introduction into Gluster basics will be given so that the attendees have a good understanding of the technology. With the basic understanding of Gluster, the explanation of the recent and future features will become very understandable.

The GNAT GPL 2015 release by AdaCore includes a cross-compiler for a new platform: Raspberry Pi 2. We have used this platform to drive and control a real model train in Ada. SPARK was used to prove absence of collisions. I will present the hardware part as well as the software part, and show a video of the model train in action.

The WPANKit is a ptxdist based Open-Source 6LoWPAN Board Support Package (BSP). The main focus is to provide a software development kit for the linux-wpan project. The linux-wpan project aims to implement a 6LoWPAN inside the mainline Linux kernel.

This talk will present the WPANKit: An Open-Source Linux BSP to develop 6LoWPAN IoT applications. It contains support for various common platforms such Raspberry Pi's and Beaglebones. Additional components like the openlabs 802.15.4 transceiver SPI transceiver or BTLE USB dongles gives you a getting started platform into the Linux 6LoWPAN world.

The WPANKit will directly build a current mainline 6LoWPAN kernel, which is the official bluetooth-next tree. This is important, because the mainline 6LoWPAN development is still much in development. Additional the WPANKit offers a large of userspace IoT software collection e.g. tshark for sniffing network traffic, libcoap, etc. On top of this BSP you can develop your IoT application, setting up a Border-Router or help at the current mainline 6LoWPAN Linux-kernel development.

Through the power of ptxdist you can easily add new own packages for cross-compiling. As well we accept patches to integrate new software into the official WPANKit repository, so we getting more and more new IoT capable software into the WPANKit which can be used by other ptxdist users.

Offline experiences are enabling more unique user experiences to naturally happen without requiring an Internet connection. From complex Embedded Systems to Mobile application, we will go over why offline is a requirement for success and how we can create that experience by using an embedded JSON database for local storage to replicate data to the cloud.

Offline experiences are enabling more unique user experiences to naturally happen without requiring an Internet connection. From complex Embedded Systems to Mobile application, we will go over why offline is a requirement for success and how we can create that experience by using an embedded JSON database for local storage to replicate data to the cloud.

With the advent of the digital transformation in today’s always-connected world, users expect to have a mobile experience that is immediate, pervasive, and aware. In this way, it is crucial to build apps that meet these expectations. Specifically, it’s building mobile apps that are always available, regardless of network connectivity and speed.

In this session, you will learn what it takes how to build an embedded and mobile solution that has a consistent user experience, both online and offline. This includes:

• Embedded & Mobile solutions & demo • Syncing the data • Storing the data • Securing the data • Cross platform data modeling

You will walk away with an understanding of the design patterns required to build an app that works online and offline using a NoSQL backend – all this, through a raspberry pi and using open source technologies to sync, store and secure your data.

There are many, many ways of writing build and integration instructions for software packages. I am going to talk about them!

Package build and integration instructions are usually written as code. It's hard to analyse code and get any interesting info out of it. It's hard to share fragments of code and expect them to still work.

A well-defined, structured format for build and integration instructions would allow developers and integrators to share, analyse and use packaging rules and build instructions, independently of any distribution.

The Baserock definitions format is a YAML format that can describe how to build a whole Linux system from scratch. It's been developed over the past 4 years. I am going to talk about the choices behind it, compromises, the pain points, and I will compare it with the other options we have for describing packaging rules.

...with clang-cl, thereby leveraging (some of) the Clang goodness we enjoy on the other platforms for the Windows-specific parts, too. This talk will highlight some of the findings made during that endeavour.

My name is Maciej and I'm dealing the PyPy funding situation. Unlike a lot of funded OS projects, PyPy is independent - we are not subject to any single large corporation power. We've gone a long way from EU R&D funding, through crowd-funding and through consulting arrangements. In this talk I would like to present our experience with funding strategies questions and caveats associated during PyPy 10 year history as well as how, at your company, you can promote open source solutions and independent vendors.

Open Source is just a better way to write software, this is very likely pretty obvious at this conference. In this talk I would like to talk about us trying to take it a step further and making it our full time job, without a corporate oversight. I would like to present the common strategies presented for open source project that we've gone through, notably:

• R&D from government grants - PyPy started as a research project sponsored through EU. The main downside is the large amount of paperwork you have to deal with.

• crowd funding - the main downside being that it works for very well defined features and the funders tend to be very demanding

• consulting - the downsides are usually need to spend time working on client code, not on the OS project itself.

All of the above does not really work for projects like cffi, which while successful, does not create any obvious streams of revenue. Additionally, I would like to present some advice how you can help open source at your company.

Do you miss SQL commands which MySQL does not support? Do you want it to have missed SQL standard features or intruduce new fancy command? Maybe contribute fix to https://bugs.mysql.com/bug.php?id=2 "Does not make Toast"? Or just replace badly written query with more efficient? With pre-parse Query Rewrite Plugings you can do most of these.

In this session I will demonstrate how to create, install and use Query Rewrite plugins. We will introduce completely new SQL command and let MySQL execute it.

At the end of September 2014, just before Oracle Open World conference, one of MySQL Labs releases presented a new killer feature for MySQL 5.7: Query Rewrite Plugins for optimizer! This is a long waited way for MySQL to both preprocess/modify query on the fly without any middle-tire software like MySQL Proxy (that can easily become a bottleneck or single point of failure) and force proper execution plan, without any change in application code. We can get functionality similar to stored outlines of Oracle RDBMS and more, as MySQL provides APIs for both literal query rewrite before parsing and for accessing/modifying query tree after parsing. During this session I will identify most important real life use cases for query rewrites, explore the features of Rewriter plugin originally created by Oracle engineers for their Lab release and provide some details about APIs and writing your own custom plugins.

Now Query Rewrite Plugins are part of current MySQL GA version 5.7. This means this is the time to actively explore them and use.

While doing the checkpoint-restore-in-userspace project for several years we've collected a number of interesting things that worth being researched and implemented. These include purely technical tasks an all levels starting from hacking the kernel and up to the CRIU itself, as well as tricky math problems. The talk is about the most interesting stuff from this list.

Checkpoint and restore is the task to get as much information as possible about running Linux processes, saving them as a set of files and recreating back the processes in the original state, so that they do not notice the change. There has been a lot of implementation of this technology, but nowadays the mainstream one is the CRIU project. During several years of work on it we've met several interesting things that could be implemented as a part or on top of the core CRIU, but that are put aside for later.

One of the interesting technical things is how to organize the logging. Logging in C/R is very critical as if checkpoint or restore fails without the most detailed traces of the process it's extremely hard to debug what's going on and what steps lead us to failure. On the other hand, generating too many log messages may slow things down significantly. How to find the balance between fast and informative logs and how to generate the messages in the fastest way possible?

An example of the kernel-level issue is -- to get information about a process CRIU does a LOT of system calls. And a huge amount of time is spent on reading various /proc files. Optimizing this thing would be a tempting kernel feature, but what's the best way? Speeding up the /proc, ability to merge severas syscalls into one, or developing yet anther subsystem that would report info about processes faster and more flexible that proc does?

As far as math problems are concerned, the best one we have is: given a graph of objects and rules for creating vertices and edges, guess (or evaluate) the sequence of rules that would generate this graph our of an empty one. In Linux language it may sound as -- how to fork(), setsid(), open() and do other syscalls to generate the process tree with resources in the state we want.

These and some other thinkers are to be presented at the talk.

An introduction to the Starlight project.

• A comparison of Lua and JavaScript
• An introduction to the project and its value
• Walkthrough of using the browser library
• Examples of interacting with the DOM from Lua
• Walkthrough of using Starlight in your build pipeline

Gerrit Code Review is a code review and project management tool for Git based projects. Gerrit makes reviews easier by showing changes in a side-by-side display, and allowing inline comments to be added by any reviewer. Gerrit is used by many open source projects, like OpenStack, Wikimedia and LibreOffice. In this talk I will present new exciting features in 2.11 release, like support for editing changes in browser, hybrid OpenID+OAuth authentication scheme just to name a few.

[1] https://github.com/Netflix [2] http://www.ovirt.org

Have you heard your colleagues discussing for weeks why your product is so slow? Did everyone have different components under suspicion? Did you sit in front of a project consisting of tens of thousands of lines of code and tried to pin down the bottle necks? Don't want to use proprietary services like New Relic APM or XRebel? In this presentation we will have a closer look on how to make visible what is inside your Java monolith with Hystrix by Netflix. After an overview is given, I will show how we implemented Hystrix into oVirt to hunt down bottle necks and architectural problems.

The networking subsystems of any operating system have grown in complexity as the set of protocols and features supported has grown since the birth of the Internet. Firewalls, Virtual Private Networking, and IPv6 are just a few of the features present in the kernel that were not even envisioned when the original UNIX releases were developed over 30 years ago. Advances in networking hardware, with 10Gbps NIC cards being available for only a few hundred dollars, have far outstripped the speeds for which the kernel’s network software was originally written. As with the increasing speed of processors over the last 30 years, systems developers and integrators have always depended on the next generation of hardware to solve the current generation’s performance bottlenecks, often without resorting to any coherent form of measurement. This presentation shows developers and systems integrators at all proficiency levels how to benchmark networking systems, with specific examples. Common pitfalls are called out and addressed and a set of representative tests are given, all using open source software.

The technical challenges in developing a benchmark aren’t limited to avoiding lying to the reader. Figuring out how to measure something reliably and repeatably in a dynamic system requires a deep understanding of all of the system components and how interactions among them can conspire to create false measurements. A non-networked system, where the interconnections and interactions among the various components are, or should be, visible, is still complex enough to trip up many developers. A networked system is far harder to measure for several reasons, including: asynchrony, visibility and the lack of well synchronized clocks.

In this talk we will present our experiences measuring various components of the FreeBSD network subsystems, including generic forwarding, IPSEC, TCP as well as both of the commonly used firewalls (IPFW and PF). We present not only our measurements but the lessons learned in finding the right measurements and how to reliably reproduce our results. Common pitfalls are called out and addressed and a set of representative tests are given. A secondary outcome of this work is a simples, open source, system for network test coordination, Conductor, which is also described. All of our code, scripts, configurations, and test results are open source and hosted on github. This work is part of an ongoing longitudinal study of kernel network performance which continues to evolve over time.

As architectures decompose into smaller pieces, figuring out the root cause of latency can become quite tricky. This session will review distributed tracing tools that can be used in your production systems to debug performance problems. While the focus is on Zipkin tools in practice, we'll also discuss related works.

Latency analysis is the act of blaming components for causing user perceptible delay. In today's world of microservices, this can be tricky as requests can fan out across polyglot components and even data-centers. In many cases, the root source of latency isn't a component, but rather a link between components.

This session will overview how to debug latency problems, using call graphs created by Zipkin. We'll use trace zipkin itself, setting up from scratch using docker. While we're at it, we'll discuss how the model works, and how to safely trace production. Finally, we'll overview the ecosystem, including tools to trace ruby, c#, java and spring boot apps. We'll wrap up with a look at simulation with Spigo and future works in Distributed Context Propagation.

When you leave, you'll at least know something about distributed tracing, and hopefully be on your way to blaming things for causing latency!

An AdaCore intern has rewritten the CrazyFlie drone software, originally in C, into SPARK. In addition to fixing some bugs, this allowed to prove absence of runtime errors. I will present the various technics used to achieve that result, and plan to do a live demo of free fall detection.

In this half hour lecture we draw from experiences of delivering half day IoT workshops while focusing on the Bluetooth and Bluetooth Smart data transports for M2M communication. Several demonstrations illustrate the topic in question, emphasized by a whirlwind tour of IoT device classes on the mobile IoT lab [1].

[1] http://dev.europalab.com/down/msvb-iotrig1.jpeg

We finish with a study of the (also Bluetooth supported) Relayr device and software environment.

In this half hour lecture we draw from experiences of delivering half day IoT workshops while focusing on the Bluetooth and Bluetooth Smart data transports for M2M communication. Several demonstrations illustrate the topic in question, emphasized by a whirlwind tour of IoT device classes on the mobile IoT lab [1].

[1] http://dev.europalab.com/down/msvb-iotrig1.jpeg

We finish with a study of the (also Bluetooth supported) Relayr device and software environment.

Federation was introduced in OpenStack release "Juno", but is still an interesting topic and is still being developed. Even more, we want to make federation the first-class citizen in OpenStack Keystone. This talk will give an overview of why one would use federated identity for his cloud.

Although Keystone implements Identity API, it doesn't try to be a user management tool and encourages administrators to manage users with existing fully-fledged tools. Federation allows users to authenticate with their username and password at a trusted identity provider, get a token from it and use it to authenticate in Keystone, while Keystone stores information about the user neither in database, nor in LDAP.

In the talk I will tell about history of identity federation in OpenStack keystone, about who uses it, about existing problems, about general architecture and features.

Mass surveillance and targeted attacks on mobile devices are getting easier and more common. A great number of mobile apps have been developed to assist users protect their privacy, but little has been done to address the issues facing distribution of the apps themselves. Basically all of the app stores except F-Droid track their users in detail. Meanwhile, we are working to make F-Droid even more private. Google Play is blocked in many countries, and app stores like Play or iTunes often censor to comply with regional law, whether just or not. Regional app stores are often cesspools of malware. In many countries, people exchange apps through web forums, email, bluetooth, SD Cards, or any other method they can figure out, whether safe or not. Effective techniques for circumventing censorship and internet outages exist, and work in many places, but none work in all, and it is very difficult to keep track of them all. This current state requires users, trainers, developers, and organizations to be fluent in many technical details in order to effectively get and distribute mobile apps and media around the world.

In Cuba, people share apps via mesh networks and thumb drives. In Vietnam, swapping apps with Bluetooth is widespread. In China, the internet is ubiquitous but heavily filtered and monitored; but "collateral freedom" techniques have proven effective. Each of these workarounds can also be useful in many other parts of the world so F-Droid is including them all in a unified user experience. All of these distribution methods are included in F-Droid, and we are now working to provide a simple, smooth user experience, with three use cases in mind:

• The developer is in control of a simple set of commands that automate the entire distribution workflow for making highly secure, reproducible builds then getting them out through all possible channels.

• Organizations and trainers can use these tools to make curated collections of apps and media use, without getting caught up in the technical details of the whole process.

• The end user gets a familiar app store experience, regardless of the complexity behind their successful connectivity.

F-Droid is an installable catalogue of FOSS (Free and Open Source Software) applications for the Android platform. The client makes it easy to browse, install, and keep track of updates on your device.

Guardian Project creates easy to use secure apps, open-source software libraries, and customized mobile devices that can be used around the world by any person looking to protect their communications and personal data from unjust intrusion, interception and monitoring. Whether your are an average citizen looking to affirm your rights or an activist, journalist or humanitarian organization looking to safeguard your work in this age of perilous global communication, we can help address the threats you face. To help make this software accessible, we run mobile security training in various forms, and create HOWTOs and tutorials for all to learn from.

Author Bio: Hans-Christoph Steiner spends his time making private communications software usable by everyone, designing interactive software with a focus on human perceptual capabilities, building networks with free software, and composing music with computers. With an emphasis on collaboration, he has worked in many forms, including free software for mobile and embedded devices, responsive sound environments, free wireless networks that help build community, musical robots that listen, programming environments allow people to play with math, and a jet-powered fish that you can ride. To further his research, he teaches and works at various media art centers and organizes open, collaborative hacklabs and barcamp conferences. He is currently building encrypted, anonymous communications devices as part of the Guardian Project as well as teaching courses in interaction design and media programming NYU's Interactive Telecommunications Program and workshops around the world.

Using a Docker image of the official Pyramid quick tutorial, we'll go through some of its basic examples of implementation.

Using a Docker image of the official Pyramid quick tutorial, we'll go through some of its basic examples of implementation.

All about NPLN. What it is, what are the aims, what is the current status.

The first Electronic Design Automation (EDA) devroom in 2015 at FOSDEM has been a great success. Since then I had been working on NPLN, my personal pet project to help me and others collecting and computing the info we already have about OSHW Boards, Circuits, and their models (eg Spice, IBIS).

Actually, I had been digging in techniques from the eighties to find errors and compute hand-outs for repairing. And yes, I like Open Source.

So NPLN currently is a mixture of a webcrawler, of spicelib and edacore, and ramps it up to Artificial Intelligence.

I want to share my work since last FOSDEM with you, and I hope for your feedback and ideas, as well as spreading the word.

Designers in an open source community or environment are not easy; neither for the designer, neither for those working with her/him. Open Source and Free Software communities have an alternative work and collaboration culture compared to classic working environments. In this talk, we can learn though how to add transparency to our workflow, and praise "sharing is caring" more than "made by me".

Designers in an open source community or environment are not easy; neither for the designer, neither for those working with her/him. Open Source and Free Software communities have an alternative work and collaboration culture compared to classic working environments.

Lately, designers have taken a more and more important role in such communities, originally initiated by developers and programmers. Just think of the Firefox logo, how important it is to such a big movement and community.

However, designers are difficult beings; we often can't get over our ego, are perfectionists in unneeded ways and often, like magicians, don't want to share our materials or tricks. That's why it's often hard for a designer to work "in the open".

We can learn though how to add transparency to our workflow, and praise "sharing is caring" more than "made by me". Licenses like Creative Commons, Open Document Formats and similar. are the most powerful tools of a designer in an open source community. We are able to become better designers, and better contributors at the same time, following a few simple principles.

The Embedded Multicore Building Blocks (EMB²) are an open source C/C++ library for the development of parallel embedded systems. Based on MTAPI, a standard for task management in embedded systems, EMB² relieves software developers from the burden of thread management and synchronization which significantly improves reliability, performance, and productivity. This talk describes the underlying concepts, gives an overview of the main components, and explains their usage by means of examples.

Multicore processors increasingly find their way into embedded systems. However, leveraging the power of such processors requires to parallelize the applications, which is often an intricate and error-prone task. To solve this problem, various libraries and language extensions for parallel programming have been developed in the past decade. However, most of these approaches are intended for desktop or server applications and do not take into account typical requirements from the embedded domain. For example, there are usually no guarantees regarding memory consumption and real-time behavior.

The EMB² library has been specifically designed for embedded multicore systems (https://github.com/siemens/embb/). It builds on the standardized Multicore Task Management API (MTAPI) and is independent of the hardware architecture (x86, ARM, ...). As a major advantage, EMB² supports heterogeneous systems consisting of different processors typically found in modern systems-on-a-chip. Unlike existing libraries, there is also support for task priorities and affinities, which allows the creation of soft real-time systems. Additionally, EMB² provides basic parallel algorithms, concurrent data structures, and skeletons for implementing stream processing applications.

Since before its standardization by the IETF in 2003, the XMPP Standards foundation and its community has put lots of effort into protocol design, documentation and implementation. But this technical work alone is not enough to ensure the success of XMPP in the real world.

What should we be working on, as a community, to bring freedom of communication to the non-technical masses?

This talk explores the non-technical aspects of developing an open communication platform for the internet. XMPP has been continuously developed on the technical front for over 15 years, but what is our goal?

For many folk in the community, the goal is giving people the ability to communicate freely by giving them an unrestricted choice of software and service. Yet instead of outreach to those people beyond our community, our efforts are primarily poured into mailing lists, technical specifications and code. Small efforts to engage with those outside of our community and beyond our "comfort zone" of technical work can make a large difference.

We'll look at some of the work that has been, is being, and can be done by all of us to tackle today's proliferation of non-free proprietary messaging silos.

Lowering the barrier of entry and working on hardware & microcontrollers using JavaScript and open web technologies.

A whole new class of microcontrollers (such as the Espruino, Tessel 2 or MozOpenHard Chirimen or BBC MicroBit) are enabling new ways for interacting with hardware - we are not limited to clunky and error-prone low-level languages, and proprietary tools any more: new tools are built in HTML5 & JavaScript, and hardware can be programmed in more user-friendly languages such as JavaScript or even Python. Knowing how to wield the powers of open web technologies, we can build our own tools and create our own hardware devices, robots, automatons or interconnected IoT devices; even build our own tools to help us along the way. All this using nothing more, than HTML5, CSS, JavaScript. During the talk I will show several such easy-to-understand demos, interconnected microcontrollers controlled from phones (but no apps, only the browser!) and tools built entirely on web technologies.

Over-the-air (OTA) audio identification provides us means to recognise sounds even in noisy environments. Popular uses for OTA identification includes recognition of audio tracks, radio or television stations, advertisements in cinema theatres & malls, etc...

In this talk we will take a look at how an OTA identification system is like and go over its significant components one by one. We will understand the underlying physics and governing mathematical equations. We will also talk about open source software and libraries, methodologies, algorithms, and the literature.

By the end of this talk, we will learn basics of how to build and develop a system for acoustic fingerprinting and matching a partial audio recording with an audio track or a real-time stream of audio.

I will discuss MySQL and MariaDB parallel replication implementation, including their strengths, weaknesses and tuning parameters. I will also present benchmark results from real Booking.com workloads.

In the last 24 months, MySQL replication speed has improved a lot thanks to implementing parallel replication. MySQL and MariaDB have different types of parallel replication; in this talk, I present in detail the different implementations, with their limitations and the corresponding tuning parameters (covering MySQL 5.6, MariaDB 10.0, MariaDB 10.1 and MySQL 5.7). I also present benchmark results from real Booking.com workloads. Finally, I discuss some deployments at Booking.com that benefits from parallel replication speed improvements.

Defining abstractions and mechanisms for inter-process communication is at the heart of every new microkernel design. This talk will introduce MH, a microkernel at its early stages built to experiment with the idea of a microkernel interface heavily inspired by hardware architecture.

The talk will continue by showing how, by exposing an interface composed of entities well known to OS-level engineers, such system can be used to express classical operating systems interfaces or to experiment with newer ideas altogether.

This project provides a C++ library that eases microcontroller programming. Its aim is to provide an interface simple enough to be able to create complex applications, and optimized enough to enable small microcontrollers to execute these applications.

The other aspect of this library is to be multiplatform. Indeed, it is designed to provide the same API for a simulator (named SASIAE) and for AVR-based and ARM-based microcontrollers.

The project began in 2014 while my association, Eirbot, was participating to the French contest of Eurobot. Indeed, the association faced a new challenge. The robots, which were controlled by AVR-based microcontrollers would be controlled by ARM-based microcontrollers. The objective was to renew an old code written in C, and make use of a simulator to test the code.

To solve these issues, and some others, Aversive++ offers these services :

• Provide a base code to design control systems.

• Provide a communication layer with some systems used in robotics (GPS, accelerometers, etc...)

• Provide a lot of tools to manage the application's memory securely, mainly by applying the same constraints as in the aeronautics industry.

• Follow the C++ philosophy : what you don't use doesn't cost you.

• Being able to execute the application of a microcontroller on a simulator.

• Being multi platform. Actually, being able to use the same application code on different microcontollers with a few or no modification.

• Provide a compile-time verification feature. Indeed, it is possible to warn the user when he is using badly the microcontroller before even executing the code. This will help the testing phase of an embedded project.

You can go to the project website : http://aversiveplusplus.com

This short introductory presentation with show Pythonistas and Pythoneers how Python can and is used in many ways with LibreOffice and inside LibreOffice. It will show: - how LibreOffice can be remote controlled from a Python program - how LibreOffice extensions can be written in Python and make it do much more - how Python can be used to integrate LibreOffice with other applications - how unittests written in Python can help LibreOffice itself to become even better - where to find help and resources on using Python with LibreOffice

This short introductory presentation with show Pythonistas and Pythoneers how Python can and is used in many ways with LibreOffice and inside LibreOffice. It will show: - how LibreOffice can be remote controlled from a Python program - how LibreOffice extensions can be written in Python and make it do much more - how Python can be used to integrate LibreOffice with other applications - how unittests written in Python can help LibreOffice itself to become even better - where to find help and resources on using Python with LibreOffice

Hammerspoon is a tool for powerful automation of OS X. At its core, Hammerspoon is just a bridge between the operating system and a Lua scripting engine. What gives Hammerspoon its power is a set of extensions that expose specific pieces of system functionality, to the user.

You can write Lua code that interacts with OS X APIs for applications, windows, mouse pointers, filesystem objects, audio devices, batteries, screens, low-level keyboard/mouse events, clipboards, location services, wifi, and more.

Typically you would write a configuration file in Lua that connects events to actions. You might want to bind a keyboard shortcut to a series of window operations, or an applescript. You might want to run a series of commands when your wifi interface connects to your home network. You might want to display an alert when your battery drops below a certain percentage. You might want to do something crazy like have iTunes automatically start playing when your Mac detects you are in Paris.

Linux containers as a virtualization solution are becoming more prevalent. An example of a container solution is rkt, whose development started end of 2014. Under the hood, container software on Linux uses the same cgroups and namespaces API. Both container software and kernel code for containers continue to be developed.

Alban will first describe the Linux API that make containers possible: namespaces and cgroups. Then he will explain how rkt containers use this Linux API.

Massive graph data sets are pervasive in contemporary application domains. Hence, graph database systems are becoming increasingly important. In the study of these systems, it is vital that the R&D community has shared benchmarking solutions for the generation of database instances and query workloads having predictable and controllable properties. Similarly to TPC benchmarks for relational databases, benchmarks for graph databases have been important drivers for the Semantic Web and graph data management communities. Current benchmarks, however, are either limited to fixed graphs or graph schemas, or provide limited or no support for generating tailored query workloads to accompany graph instances.

To move the community forward, a benchmarking approach which overcomes these limitations is crucial. In this talk, we present the design and engineering principles of gMark, a domain- and query language-independent open-source graph benchmark addressing these limitations of current solutions. A core contribution of gMark is its ability to target and control the diversity of properties of both the generated graph instances and the generated query workloads coupled to these instances. A further novelty is the support of recursive regular path queries, a fundamental graph query paradigm. We illustrate the flexibility and practical usability of gMark by showcasing the framework's capabilities in generating high quality graphs and workloads, and its ability to encode user-defined schemas across a variety of application domains.

This is joint work with Guillaume Bagan, Angela Bonifati, Radu Ciucanu, Aurélien Lemay, and Nicky Advokaat.

Audience: Developers, trying to optimize processing of highly connected data sets

This is joint work with Guillaume Bagan, Angela Bonifati, Radu Ciucanu, Aurélien Lemay, and Nicky Advokaat.

When Oracle released Java 7 GA, it contained a serious loop optimization bug, affecting Apache projects like Lucene, Solr, or Elasticsearch. Since that time, the Apache Lucene team works together with the Oracle and OpenJDK developers to test early-access releases with Apache Lucene's codebase. Due to Apache Lucene's heavy, low level code with many tight loops and unusual code patterns, it is an ideal testing environment for the Hotspot optimizer. Loops, iterators, and bitset operations are executed millions of times per full text query to execute finite state automata, collect and filter results, and sort them. Bugs caused by mis-compilation of code that are hard to reproduce in isolation can be easily reproduced with Lucene. In addition, Lucene uses a pseudo-randomized testing infrastructure triggering different Hotspot optimizations on each test execution. In this talk, Uwe will show the current state of Java 9 EA testing. He will also present the problems caused by hard to reproduce issues, e.g. occurred after the changes to arraycopy or AVX optimizations in Hotspot.

WebRTC is a disruptive media technology bringing real-time multimedia communications to HTML5 standards. WebRTC is currently available for billions of users as a built-in feature of common browsers such as Chrome and Firefox. This makes possible the emergence of a truly open and interoperable technology competing with proprietary conferencing solutions and enabling developers to create specific-purpose WWW peer-to-peer real-time media applications in a simple and seamless manner.

However, WebRTC developers commonly require more than plain peer-to-peer video conferencing. For this, we introduce Kurento, a Free Open Source Software (FOSS) initiative build on top of GStreamer providing developers a set of high level abstract APIs making possible the creation of HTML5 multimedia-enabled web application. Kurento pushes GStreamer to a next level building a media server with interesting features such as media recording, media mixing for group communications, media adaption and transcoding, media augmentation, integration with computer vision capabilities, etc. In the talk we will introduce what’s Kurento and how WWW developers can take advantage of it showing the following aspects of the framework: •First, introducing Kurento Java and JavaScript APIs and we explain how they interact with the signaling plane in an application server. This allows WebRTC application developers to create their application logic using popular technologies such as Java EE or Node.js. •Second, by presenting a unique media plane written on top of GStreamer. GStreamer is based on the concept of media pipelines, which can be seen as chains of media elements performing operations to a media flow in real-time. Currently there are more than 1000 media elements written for GStreamer implementing many different capabilities such as codecs (e.g. H.264, H.263, VP8, etc.), recorders and players (for storing/recovering media from files), blenders (for augmenting media), filters (i.e. face blurring, face recognition, etc.) and others. Hence, Kurento enables to inject WebRTC streams into a chain of such elements and perform, in real time, the operations the developer wishes.

To demonstrate the capabilities of Kurento, this talk will also present some advanced demos and examples showing augmented reality and computer vision capabilities applied on top of real-time video-conferences

I’ve been working with several design universities now to get the students involved and working on open source projects. Especially for usability testing this is very little investment with a huge benefit for the project, professors and the students.

I’ll present the collaborations I did so far and how we can push it forward more.

Dynamic memory management has always been a source of trouble, and garbage collection is just a way to overcome the lack of proper memory management in many languages. This presentation shows how Ada addresses this issue in several original ways: first by requiring much less dynamic memory than other languages, and then by providing powerful tools for controlling allocation and deallocation when it is necessary.

Software Collections are a consistent way of developing RPMs that allows for parallel installation of binaries. With containers and unikernels being all the rage, do we still have a need to parallel install binaries? Why not just make a new container? A new VM? Come to our talk to understand a little bit mora about what Software Collections are and why the authors believe they are still very relevant. We might even be able to work in a demo!

I will present a system for data interchange based on the structural subset of Verilog, extending the usage to express the additional data for layout and schematics. This is an intermediate format to provide a common point for interchange between tools.

More detail is available at http://gnucap.org/dokuwiki/doku.php?id=gnucap:user:netlistimportand_export

The intent is to use this intermediate format to provide convenient data interchange, including bi-directional interchange between incompatible competing tools, for example between Kicad and gEDA. It also eventually should enable things we don't have yet in free EDA, such as post-layout simulation, and schematic vs layout verification.

Tox is a very well-known tool, written in Python, that allows users to run tests inside various virtual environments created using virtualenv. This approach prevents tests from being truly reproducible. We will see in this talk how virtualenv can be replaced by GNU Guix, a functional package manager, in order to improve tox. We will give real-life examples using Python packages from the OpenStack project.

Using virtualenv in tox raises a few issues:

• only the packages available on PyPI can be installed, which means users sometimes have to "manually" install some packages using their distribution's package manager (for instance, lib*-dev on Debian, gcc...);
• when multiple virtual environments need to install the same package, it is duplicated in each of the virtualenvs, wasting disk space;
• bad level of abstraction: nowadays, every language come with its own package manager (pip, npm, cpan...) instead of using a single, robust package manager;
• tests are not really reproducible because the test environments are not completely isolated from the rest of the system (think of environment variables, of the whole filesystem, etc.).

GNU Guix is a functional package manager (as in "functional programming") based on Nix. It allows users to build packages in a completely isolated environment. We will introduce this tool and show how the "guix environment" command can be used to create an isolated environment similar to a virtualenv.

Last but not least, we will see how virtualenv can be replaced with Guix in tox so that users can benefit from all the features of Guix without changing their usual workflow. We will show some examples using packages from the OpenStack project, such as python-keystoneclient.

On today's supercomputers, chemists, biologists, physicists and engineers are sharing the same system and they all need different software. Environment Modules have been the way since the '90 that users select the software they need. They allow users to load and unload the packages they want. They get to control which version of the software they use, rather than the system administrators. Lmod, implemented in Lua, is a modern replacement for the venerable TCL/C based tool. Lmod offers many features to handle the vastly more dynamic software environment than the original tool was designed to handle.

Lmod is a modern, flexible, robust environment module system: the system tool that "sets the table" by helping supercomputer users load the software packages they need to do their work. They get to control which version of the software they use, rather than the system administrators. It is a Lua-based drop-in replacement for the venerable TCL/C environment module system. Because needs vary across the diverse computational research community, module systems like Lmod are mission-critical, ubiquitous, and expected on such systems: users need help selecting the correct combination of tools from among the thousands available on modern, large-scale systems.

This is not a talk about Lmod's features or design; instead, the focus is on process, community, and culture. What is it like to develop, maintain, and support a tool for a community that is often unaware that it (or Lua) even exists? How does one go about diagnosing and correcting problems on systems to which you cannot get access?

But the talk also addresses an important Lua-related issue. A module system loads a given software package by interpreting a 'modulefile' that describes the details of the environment that software package needs. Lmod's native modulefiles are Lua programs; Lmod parses legacy TCL modules by translating their instructions into Lua. This approach has been very successful, but has not been without its challenges: this talk includes an introduction to some of the associated technical issues and edge cases.

This has been an interesting ride, from a local tool deployed at a single site in Texas, to an open source mainstay that is mission critical at hundreds of supercomputer centers around the world. World domination through Lua and Lmod, one center at a time!

One of the foundations of a trusted security package is the breadth and range of testing done on it. There are a number of tools and techniques that can be used to enhance the testing coverage of a library or software package - reducing bugs and vulnerabilities and further gaining the trust of a user base. This session will go through the different types of testing and tools used to help make the wolfSSL SSL/TLS and wolfCrypt cryptography libraries tested, trusted, and secure.

Networks Functions Virtualizationm or NFV, is a very hot industry topic at the moment. What you might not know is what it means - telecommunications companies who have traditionally used only proprietary software to run their core services are now embracing free and open source software, and in the process changing the way they build and deploy core telco serives to be more open.

This presentation will review what makes up an NFV stack in OPNFV, covering OpenStack, OpenDaylight, Open vSwitch, DPDK, QEMU, the Linux kernel, and other projects. I will present the work being done in these communities to enable the migration of telco applications to this platform, particularly in the areas of improved network dataplane performance, enabling better management of applications running on the platform, and the ability to run real-time guest workloads with KVM.

I will also look at the organisational transformation in the telecommunications industry, and the adoption of DevOps and agile practices, and the evolving culture of the telecommunications industry, and how the changes that are happening at the request of the telecommunications industry benefit everyone, from the home hardware hacker hobbyist to IT operations in small and large companies.

Networks Functions Virtualizationm or NFV, is a very hot industry topic at the moment. What you might not know is what it means - telecommunications companies who have traditionally used only proprietary software to run their core services are now embracing free and open source software, and in the process changing the way they build and deploy core telco serives to be more open.

This presentation will review what makes up an NFV stack in OPNFV, covering OpenStack, OpenDaylight, Open vSwitch, DPDK, QEMU, the Linux kernel, and other projects. I will present the work being done in these communities to enable the migration of telco applications to this platform, particularly in the areas of improved network dataplane performance, enabling better management of applications running on the platform, and the ability to run real-time guest workloads with KVM.

I will also look at the organisational transformation in the telecommunications industry, and the adoption of DevOps and agile practices, and the evolving culture of the telecommunications industry, and how the changes that are happening at the request of the telecommunications industry benefit everyone, from the home hardware hacker hobbyist to IT operations in small and large companies.

This will be a Workshop about Graphic Primitives. These are used for the Office's EditViews for visualization. All DrawShapes are visualized using them, Draw/Impress use them to display the whole EditView. They are also used for Overlay Objects like Selections and Interactions. This talk will give an overview of DrawingLayer Primitives, their usage and future, their basic concepts, how to use them and how to create own Primitives to make use of them.

There are now two major organizations developing automotive FOSS software and a third may be contributing as well. This means there is lots of automotive software available and now its able to run on cheap, available hardware like the Raspberry Pi.

This talk will take us through the available FOSS software stacks that are available for automotive. This last year has produced a lot of working software from fiber-optic networking drivers in the Linux kernel, complete In-Vehicle Infotainment stacks, to a newly released Qt Automotive. There has also been a change in available hardware to run this software on, new boards like the Minnowboard Max, Renesas' Porter board, and even the Raspberry Pi 2. This talk will try and cover the entire software ecosystem and how it matches to hardware, how you can get involved today, and what the future holds.

Linux kernel contains roughly 71 filesystems and a good portion of them exists solely to support legacy systems. User space storage is easier to implement, maintain and scale. Instead of resisting user space implementations of iSCSI, NFS and distributed filesystems, Linux kernel developers should embrace and standardize on FUSE and DPDK/SPDK like I/O architecture.

Other than the root filesystems and its supporting code, there is little to no reason for the rest of the storage code base to remain inside the kernel. From NTFS, NFS-Ganesha to GlusterFS, it has been clearly demonstrated that user-space storage systems work well. Recent open source storage projects moved further apart from the kernel community and adopted Python (OpenStack Swift), Java (Hadoop HDFS) and Golang (Minio) languages. POSIX is not only irrelevant, but an impediment to modern distributed storage systems.

Linux as a stand-alone operating system does not help much when it comes to distributed authentication, high-availability (HA) and fault-tolerance. Most of the modern applications entirely run as non-root user with all its dependencies managed within its home directory. Authentication is based on SSL/TLS and certificates over HTTP. HA is achieved through centralized discovery and consensus algorithms through Zookeeper (Java), Doozer (Go), Consul (Go), etcd (Go) like projects for high-availability.

On the other hand, Linux has quietly grown as a popular microkernel of choice under the name of hypervisors and linux-container-hosts. It is time to admit and embrace the change.

Cytomine (http://cytomine.be, source code on https://github.com/cytomine) is, to the best of our knowledge, the first open-source rich internet application to enable highly collaborative and multidisciplinary analysis of multi-gigapixel imaging data.

Built at the University of Liège with state-of-the-art RESTful (Grails), noSQL (MongoDB, Redis) and automated deployment (Docker) technologies, it supports both remote visualization, collaborative semantic annotation, and semi-automated analysis through the web, making it an ideal tool for collaborative research, teaching and diagnosis in every large-image related topics.

Its design was driven by life science and bioimage informatics research needs: software versatility, interoperability, modularity and extensibility, image recognition tailored via learning from ground-truth data and proofreading tools, reproducible research, and data accessibility and reusability.

It is being used for years by our collaborators working with large sets of bioimages in numerous domains including cancer research, development, and toxicology, and is now adapted for pedagogical purposes.

Overall, we believe Cytomine is an important new tool of broad interest to foster active communication and distributed collaboration between life, computer and citizen scientists, but also physicians, teachers and students, in an unprecedented way using machine learning and web communication mechanisms.

After 5 years of active developpement, use in research and education, our team will be proud to annonce at FOSDEM that the entire source code will be available at this date under an Apache (v2) licence.

Our lightning talk will focus on Cytomine main features, illustrated by research and teaching practical examples, and will broach how we want to carry on our project in the future.

Many FOSS projects have a carefully designed governance. But to which extent that governance fits the real inner life of the project? In this talk I will present some ways of measuring to which extent governance may be subverted (or not) by real practices, how that can be detected, and tracked. From this base, I will show how a continuous tracking of those behaviors can contribute to a more fair development community, and to increase the trust in the project. The discussion will be framed by the concept of "open development analytics".

Many FOSS projects have developed governance rules. Specially when companies are involved, those rules model the ethos of the project. They may try to avoid, for example, that a single company controls the main aspects of the development process. Or that independent developers are treated equal than those employed by companies. Or that the "old generation" doesn't have an overwhelming weight in decisions. Usually, those rules define governing bodies, how they are elected, and which binding rules those bodies may produce. Therefore, governance is enforced as a kind of "law" for the project.

But you have law, and you have reality. In the case of FOSS projects, you have bylaws, governing bodies, approved codes... and then you have tools, development practices, and developers. The fact that most of the development actions are mediated by tools allows for the examination of what is happening in the project. From there, you can learn to which extent that conforms with the governance envisioned. In other words, tools can be examined, to see to which extent the reality of the project fits what the project wanted them to be.

The talk will show how using simple software development analytics some specific areas can be analyzed from this point of view. For example, a good proxy for who soft-controls a project is who is contributing to it (authoring code, reviewing code, closing tickets, participating in discussions). A good proxy to how fair it is to developers is how they are treated in the code review process when they propose changes. And that way, several metrics can be defined to help understand what is really going on.

All of this will be framed using the concept of "open development analytics". Open development analytics can be understood as a step forward in project transparency and community openness. They can be used to provide useful about how the project is really behaving, so that anyone can detect problems and deviations from the intended behavior. I will explain how this makes the project more resilient, its supporting community more self-aware, and helps increase trust by third parties.

Often micro-benchmarks are used to decide a feature is slower or faster than another. Javascript engines are getting better and better and as a result micro-benchmarks show performance that has no correlation with the used feature. Here I will debunk some micro-benchmarks by explaining what happens internally in the Javascript engine, together with formulating advice on how to properly benchmark features.

Nageru is an M/E (mixer/effects) video mixer capable of high-quality output on modest hardware. We'll go through the fundamental goals of the project, what we can learn from the outside world, performance challenges in mixing 720p60 video on an ultraportable laptop, and how all of this translates into a design and implementation that differs significantly from existing choices in the free software world.

Nageru is an M/E (mixer/effects) video mixer capable of high-quality output on modest hardware. We'll go through the fundamental goals of the project, what we can learn from the outside world, performance challenges in mixing 720p60 video on an ultraportable laptop, and how all of this translates into a design and implementation that differs significantly from existing choices in the free software world.

One of the impediments to becoming an active technical contributor in the OpenStack community is setting up your own R&D environment which includes making your own cloud. How much RAM do you really need? How important is processor speed? What else do I need to know?

Using RDO-manager, get a basic cloud up and running with the fewest steps and minimal hardware so you can focus on the fun stuff - development!

After this presentation, you will be able to build your own basic cloud using RDO-manager.

An update on how the proposed Java Platform Module System and the modularization of the JDK will affect developers in general and those who work on the JDK in particular.

Hear about the huge improvements we made in VCL in the last year.

Come hear about the work on the Visual Class Library (VCL) in the last year - the bottom of the cross-platform graphics system that LibreOffice is built on. See how we've re-factored the per-platform backends, improved the lifecycle mechanism (VclPtr), re-vamped our main-loop (the idle handler re-work) as well as many other long overdue improvements. Also hear about how we're using OpenGL to accelerate rendering and improve quality.

TokuDB has gotten a lot of press lately and with the promise of crazy write speeds, people are jumping in on production if not for exploratory work. But before you take first dib, what are the essential things you need to know?

TokuDB has gotten a lot of press lately and with the promise of crazy write speeds, people are jumping in on production if not for exploratory work. But before you take first dib, what are the essential things you need to know? How does TokuDB achieve insane write speeds, what re the tradeoffs, what are the basic configuration options and specific use cases?

ircb, or IRC Bouncer, is an attempt to make next gen IRC bouncer as a service, from the ground up. It focuses on: - easy setup, deployment, management - low barrier and automated entry point for users - handle scale: - support multiple nodes to distribute connections to IRC networks - load balance client connections - optimize network IO usage, by using intelligent caching - support multiple client connections for the same connection to IRC network

Source code: https://github.com/waartaa/ircb/ Design doc: https://github.com/waartaa/ircb/wiki/Design-docs

ircb1 is a IRC Bouncer as a service, made for humans. It's currently functional as a basic IRC bouncer, however, unlike mainstream IRC bouncers, it supports multiple client connections for the same IRC network connection for a user. It aims to provide a scalable bouncer service along with easy setup, deployment and management. It also envisions to provide a low barrier entry point for users, where users can join and start using the service in an automated fashion, without going through manual processes.

Although, ircb is a standalone product, it is also one of the core components of waartaa2. waartaa is our attempt to create an open source SAAS communication and collaboration tool, around IRC. We also participated in GSoC under the Fedora umbrella. However, we hit various roadblocks with the initial code base given to it's monolithic structure. So, we started breaking down the app into micro services. Thus, ircb, the scalable IRC bouncer to empower waartaa, was born.

IRC networks limit the number of connections for an IP, and this limit has to be manually negotiated, and the process takes time. We came to know of this during maintaining a demo instance of waartaa on a single node, when Freenode will stop rejecting IRC connections from our IP. That's why we are looking forward to have a multi node model for ircb, where we can intelligently distribute the IRC network connections, as needed. We are also brainstorming to figure out an intelligent way to load balance connections from IRC clients to the bouncer service in a stateless fashion. You can find some insight about it in our initial design docs3. We are also trying to develop a reactive store layer to empower realtime applications, in our case, waartaa.

We want to showcase our project to the intelligent folks present at FOSDEM with the hope of getting valuable feedback and contributors.

Much of Twitter's infrastructure is powered by open source. For cluster management we use Apache Aurora and Apache Mesos to run a variety of workloads across multiple large clusters, each typically tens of thousands of servers. Almost all of Twitter's stateless services run in Aurora/Mesos and we're constantly working to migrate other workloads into Aurora/Mesos. Through many years of development, and lots of hard learned lessons, we've helped build an extremely reliable, scalable, and robust platform.

Mesos provides a unified abstraction of cluster resources to one or more scheduling frameworks (Aurora is one example) which run a variety of workloads. To fully achieve the resource abstraction, Mesos must ensure that co-located jobs are well contained and isolated from each other. To do this Mesos has several options for containerization and resource isolation, implementing its own control of Linux cgroups and namespaces or delegating to external providers like Docker.

In this talk I'll speak about some of the lessons learned running large scale containerized infrastructure at Twitter and talk a lot about where we're heading next. I'll focus on isolation improvements to support other workloads and to support increased system utilization, all while maintaining (as close as feasible) the ideal resource abstraction. In particular, we're looking at effective CPU isolation when co-locating very latency sensitive services with latency insensitive batch-style workloads.

Developing and maintaining distributed systems like Hadoop is difficult. The difficulty comes from many factors, but we believe that one of the most important reasons is lacking of a good debugger for bugs specific to distributed systems. (e.g., non-deterministic hardware faults, message ordering, ..)

In the talk, we will show Earthquake, our open-source debugging framework for distributed systems. Earthquakes permutes Ethernet packets, Filesystem events, Java/C function calls, and injected faults in various orders so as to control non-determinism in the cluster. Basically, Earthquake permutes events in a random order, but the user can write his/her own state exploration policy (in Go language) for finding deep bugs efficiently. Earthquake also controls non-determinism of the thread interleaving by calling sched_setattr(2) with randomized parameters.

We will also share our successful stories about testing some Hadoop components with Earthquake. For ZooKeeper, we found a distributed race condition bug which decreases availability of a ZooKeeper cluster. We also reproduced a known ZooKeeper bug that no one had successfully reproduced for 2 years, and analyzed its cause. For YARN, we found a disk-fault tolerance bug that inappropriately marks faulty node as healthy. We also found bugs of non-Hadoop softwares, such as etcd.

With Earthquake, you can also test your real distibuted systems without any modification.

LGSL is a collection of numerical algorithms and functions for Lua, based on the GNU Scientific Library (GSL). It allows matrix and vector manipulation, linear algebra operations, special functions, and much more. LGSL is based on the numerical modules of GSL Shell, and requires LuaJIT.

LGSL offers an intuitive interface to the GNU Scientific Library (GSL) functions, giving you easy access to a well-tested scientific toolbox from your favourite Lua application. The bindings use the LuaJIT FFI, which makes the installation of LGSL a breeze. No compilation is required: all you need is LuaJIT and the GSL shared library.

LGSL is based on the numerical modules of GSL Shell. While GSL Shell is recommended as an all-in-one interactive scientific shell which includes plotting capabilities and general data tables, LGSL aims to be an easy-to-include Lua module with a more limited focus. It includes the numerical algorithms, special functions, and other goodies from GSL, as well as linear algebra operations which harness the power of BLAS. A selection of functions were reimplemented in Lua, to get the most out of LuaJIT.

In this talk, I will demonstrate the features of LGSL and discuss how it was tuned to be blazingly fast thanks to LuaJIT.

Pulp can be used to create and manage local repositories of Python packages.

Pulp enables your organization to manage repositories of software packaged in many different formats, using one set of tools. Manage RPMs, Debian packages, Puppet modules, Docker images, Atomic trees, Python packages, and more with the same technology currently used by the largest and smallest of organizations.

In this session, you will learn: - How to create local repositories of Python packages - How to upload packages to Pulp repositories - How to make Pulp automatically retrieve packages from remote repositories, like PyPI - How to install packages from a Pulp repository

http://www.pulpproject.org/

Many EDA tools are burdened by their own legacy. They started out decades ago and have been 'patched' along without a complete re-think of development methodologies and new views of usability. In this short talk I'll discuss some ideas about how that could change through (possible) emerging interests in what we do.

Background reading:

http://www.boldport.com/blog/2015/2/5/a-farewell-to-eda

http://www.boldport.com/blog/2013/09/engineers-assemble.html

http://www.boldport.com/blog/2013/05/the-myth-of-huge-component-library.html

http://www.boldport.com/blog/2013/06/the-myth-of-verified-by-others-footprint.html

http://www.boldport.com/blog/2013/06/the-end-of-myths-solving-one-of-our.html

http://www.boldport.com/blog/2014/01/so-you-want-to-start-eda-business.html

"How can I contribute?" is a panel discussion for everyone who works in "design" (visual designers, graphic designers, interaction designers, researchers).

This discussion panel is for people like me: people who use open source software daily, who promote open source software to others, and who want to contribute to open source projects but aren't sure where to start. The panel will be made up of designers, researchers, and developers who are already working in open source software.

The goal will be to give the audience some beginning steps to make a start in contributing to OSS projects. The panel will begin the discussion, and the objective will be to take questions from the audience.

This panel is for people like me: people who use open source software daily, who promote open source software to others, and who want to contribute to open source projects but aren't sure where to start.

The goal of the panel will be to give the audience some beginning steps to make a start in contributing to OSS projects. The panel will be made up of designers, researchers, and developers who are already working in open source software, and the discussion will focus on:

• How to identify what project(s) you want to contribute to (What are you interested in?)
• Where to find open source projects (Github, Sourceforge)
• How to make the first connection with a project
• How to make your first contribution

The panel will begin the discussion, and the objective will be to take questions from the audience.

In this half hour lecture we draw from experiences of delivering half day IoT workshops while focusing on the Bluetooth and Bluetooth Smart data transports for M2M communication. Several demonstrations illustrate the topic in question, emphasized by a whirlwind tour of IoT device classes on the mobile IoT lab [1].

[1] http://dev.europalab.com/down/msvb-iotrig1.jpeg

In this half hour lecture we draw from experiences of delivering half day IoT workshops while focusing on the Bluetooth and Bluetooth Smart data transports for M2M communication. Several demonstrations illustrate the topic in question, emphasized by a whirlwind tour of IoT device classes on the mobile IoT lab [1].

[1] http://dev.europalab.com/down/msvb-iotrig1.jpeg

(Please note that this talk replaces 'Build your world in webVR: MOzVR to rescue' that was to have been given by Rabimba Karanjai.)

“It used to work perfectly, then I upgraded something, and somehow…” Sounds like a déjà vu? Sometimes feel like software deployment is unpredictable? Ever wondered if you can trust your compiler or the integrity of those binary packages you have downloaded? Falling for VM/Docker images to address the shortcomings of “traditional distros”?

This talk introduces GNU Guix, a package manager that implements the functional package management paradigm pioneered by Nix to address these issues.

Guix supports transactional upgrades and rollbacks, as well as support for multiple software profiles. In this talk, I will introduce functional package management and demonstrate Guix on practical use cases. We will show that the approach provides better resource usage and transparency than "app bundles" as popularized by Docker. I will discuss the implications on (bit-)reproducible packages and environments, and how this can lead to verifiable binaries. Lastly, we will see how this extends to whole-system deployments with GuixSD, the Guix System Distribution.

Building your own media portal

Using Kaltura media open source API, in order to create media portal, with the capabilities of uploading media, search, permissions, adding customize player, adding comments, captions and creating playlists.

VoIP/SIP Monitoring and Troubleshooting have never been simpler! Our Workshop provides a brief history of classic VoIP Capture tools and introduces HOMER 5, SIPCAPTURE's flagship Open-Source VoIP Capture, Monitoring and Troubleshooting Appliance with its powerful packet capture companion tools, providing tight native integration with all major OSS VoIP Platforms (Kamailio, OpenSIPS, FreeSwitch, Asterisk and more) and hooks into external dbs/bigdata for endless integration based on the EEP/HEP Encapsulation protocol.

After several months of development Movim will finally be released in version 0.9. We are really excited to introduce you this new milestone for the free and decentralized social network that we are working on since 2008.

From the redesign of the architecture to the new user-friendly interface you will discover all the features offered by the project for the general public, but also for developers and administrators.

During this conference we will talk about mobility, encryption, content sharing, real-time and decentralization.

With more than 9 million users and 21 million repositories, Github is the world's biggest code sharing platform. Its API offers a window to the public activity of about 600,000 events a day. In this talk, Christophe will present how he transformed this activity into a graph and mapped the network flow between users, communities, programming languages, and code repositories. He will demonstrate how to gain new insights by building interest graphs and recommendation engines on top of this valuable data

With more than 9 million users and 21 million repositories, Github is the world's biggest code sharing platform. Its API offers a window to the public activity of about 600,000 events a day. In this talk, Christophe will present how he transformed this activity into a graph and mapped the network flow between users, communities, programming languages, and code repositories. He will demonstrate how to gain new insights by building interest graphs and recommendation engines on top of this valuable data

You have your code working, it solves your problem, but now its time to get it upstream. What to do next? What should I have done?

Maybe we can use lessons from Harper Lee's To Kill a Mockingbird to improve how new and established OpenStack contributors work together?

John will share some of the lessons learnt from his OpenStack Journey, including his time as a private cloud packager, vendor driver maintainer, public cloud operator, nova-core, nova-specs-core, Blueprint Czar, Release CPL and now Nova Project Team Lead (PTL).

In this presentation I will give an overview of the query rewrite framework, which you can use to write your own query rewrite plugins. There are two interfaces: Pre- and post-parse. I will give examples of each type and guide you through the basic principles of writing a query rewrite plugin.

In this presentation I will give an overview of the query rewrite framework, which you can use to write your own query rewrite plugins. There are two interfaces: Pre- and post-parse. I will give examples of each type and guide you through the basic principles of writing a query rewrite plugin.

After nearly 8 years of development, what have we learned from developing an ambitious software project in Lua?

When Prosody began, in 2008, Lua was not an obvious choice for developing a real-time network service. Compared to alternative languages, Lua had a poor ecosystem (and some say, still has). Node.js was not yet born, and the world was not used to the idea of serious high-performance services being written in high-level "scripting" languages.

Many things have changed since that time, both in the Lua world and beyond. "Why Lua?" is no longer our top FAQ, and the Lua ecosystem has improved considerably.

We faced challenges along the way, and learned a lot. This talk examines some events in our project's history as they relate to the Lua language.

Capsicum is a security framework that allows process isolation and sandboxing based on the principles of capability-based security. This talk will give a brief introduction to Capsicum and capabilities, with some comparisons to the security mechanisms available for Linux containers (namespaces, cgroups and seccomp-bpf).

Aim to cover: - Privilege separation is the most effective way of securing software against future (classes of) bugs. - Capabilities allow the "privileges" to be precisely specified. - Capsicum blends capabilities with traditional POSIX semantics, in a pragmatic way. - Comparison with (Linux) kernel mechanisms for container isolation (e.g. namespaces, seccomp-bpf, cgroups). - Current Capsicum status on FreeBSD and Linux. - Potential future Capsicum work.

James Shubin (@purpleidea) will be presenting his review of some of the important legal and licensing issues faced by commercial ventures and enterprises who are involved with or are (in particular) producing software. This will include: current practices and their impact, public discussion and prior art on this topic, the cost of different licenses, and a review and rebuttal of some of the points brought up during previous FOSDEM legal dev room presentations. More info in the full description.

James Shubin (@purpleidea) will be presenting his review of some of the important legal and licensing issues faced by commercial ventures and enterprises who are involved with or are (in particular) producing software. James will discuss: * Advantages and disadvantages to copyleft and permissive licenses * The business cost of some of the different licenses * Differences between license versions as it pertains to commercial ventures (eg: ALv2 vs. GPLv2 vs. GPLv3) * The use of "Newspeak" and "weasel words" in communication * How to interpret the data about license usage * Real world examples and repercussions of some of the business decisions * And a review and rebuttal of some of the points brought up during previous FOSDEM legal dev room presentations

In other words, what you need to know if you are embarking on almost any commercial enterprise, since there are many software and legal aspects involved these days.

i-score is an intermedia sequencer dedicated to interactive scenario authoring. Designed as a generic data sequencer, this open source software allows a remote dialog with various applications, such as Max, Pd, Live ... using show-control protocols like OSC to store and recall parameters value.

Founded by the National French Research Agency project OSSIA, the 1.0 version of i-score proposes a graphical formalism to set precise temporal and conditional relationships between events that can be interactively triggered. The edition and the execution of several independant time layers offer an unique way to manage parameters automations being attended by tools to interpolate states or to draw your own curved breakpoint function.

As the result of continuous discussions between scientists, ingeneers and users, the presentation will be articulated around well known issues identified during the development of setups for show-control or interactives setups used in museographic situations.

i-score is an intermedia sequencer dedicated to interactive scenario authoring. Designed as a generic data sequencer, this open source software allows a remote dialog with various applications, such as Max, Pd, Live ... using show-control protocols like OSC to store and recall parameters value.

Founded by the National French Research Agency project OSSIA, the 1.0 version of i-score proposes a graphical formalism to set precise temporal and conditional relationships between events that can be interactively triggered. The edition and the execution of several independant time layers offer an unique way to manage parameters automations being attended by tools to interpolate states or to draw your own curved breakpoint function.

As the result of continuous discussions between scientists, ingeneers and users, the presentation will be articulated around well known issues identified during the development of setups for show-control or interactives setups used in museographic situations.

Mail2Voice is an accessible email client designed for illiterates and cognitive impaired people. After a long way, a first stable version was published in 2015. However, right after, we engaged discussions about the future of the client. How could we address the remaining flaws and propose a totally redesigned software? This talk will present answers and new questions we found for Mail2Voice Next.

Mail2Voice is a project with a simple idea in mind: how can I use emails when I'm not able to read nor to write? From this simple question the illiterates and cognitive impaired are confronted to, Laurent Claude decided to start the Mail2Voice project. It took a while before getting a stable version but it finally came in 2015 after years of development. Still, the results were not as high as expected so we started thinking about Mail2Voice Next. This project intends to drop the current code base entirely and start anew with a better approach, based on our experience. This talk will put in light the flaws of the current software and expose what we tried, failed and achieved to address these issues. We will also discuss about the remaining questions and the perspectives of Mail2Voice Next.

The Debian Project mourns the loss of community founder Ian Murdock. Ian passed away 28th December, 2015.

Debian is only a part of his legacy but is perhaps what he is best known for. In this short event a tribute video will be screened, together with some words from members of the Debian community.

A tool, which can take an Ada package specification, and generate a command-line driver for calling the procedures declared in the package. Which of the procedures is called is controlled by the names of the arguments passed to the driver program. The presentation will cover: how to use the tool; and some details of how the tool works - using the Ada Semantic Interface Standard (ASIS).

For the Libervia project, we have developed a blogging/microblogging engine based on XMPP and PubSub. This talk explains how we have done, what we can do, and the gain of using XMPP

Blogging technologies are most of time based on centralized website with e-mail validated comments.

XMPP is a set of various technologies, and one of them is “Publish/Subscribe”. We have used this extension and other ones to build a decentralized blogging/microblogging engine.

Using XMPP has many benefits, that will be explained in this talk: - using a standard allow us to communicate with other project (Movim, Live Jabber, Jappix, etc) - comments are using the strong XMPP authentication, no need for email validation - because of this authentication, spamming is more difficult - we can change the software rendering the blog easily - comments/articles are pushed in real-time - articles or comments can be easily linked - third party software manipulation is easy

I'll also explain how some features are managed like tags, private blogging, search, etc.

Surveillance is a growing concern in Europe, and Mozilla believes that privacy and security should be treated as fundamental and not optional in the browsing experience. That's why Firefox has introduced new features for tracking protection and private browsing. Do not track is not only a way to navigate the web, it might also become part of a new privacy law in the EU. We will discuss how this has been implemented in the newest version of Firefox, next steps, and why it's important to have transparency and control in our online experiences.

Surveillance is a growing concern in Europe, and Mozilla believes that privacy and security should be treated as fundamental and not optional in the browsing experience. That's why Firefox has introduced new features for tracking protection and private browsing. Do not track is not only a way to navigate the web, it might also become part of a new privacy law in the EU. We will discuss how this has been implemented in the newest version of Firefox, next steps, and why it's important to have transparency and control in our online experiences.

A look at how the various communities and projects can collaborate to achieve common goals, and reflections on how this can fit with the life-cycle of our mature open-source EDA packages.

A look at how the various communities and projects can collaborate to achieve common goals - despite their differing design choices seemingly being etched in tablets of stone (should that be layers of copper clad FR4?).

I will aim to address some of the dynamics between project developers and their communities, reflecting on lessons I've learnt within the gEDA project - and on some of the challenges brought by working more closely with those who might be viewed as our "competition".

I will propose some areas I see as low-hanging fruit for potential collaboration - and some problems to be overcome on the way. There should also be opportunity to explore some more controversial ideas on project re-factoring, drawing upon aspects of last year's EdaCore proposal, and my thoughts on how a common underlying library might be used to bring about the start of project convergence without losing the individual identities and design goals of the projects involved.

If the audience is receptive (or argumentative!), a decent Q&A session would be welcome here!

Turris Omnia aims to bring to the market afordable, powerful and secure SOHO router which is completely open-source and open-hardware. As a operating system it uses our own fork of OpenWrt which has some additional features such as automatic security updates. This talk will cover few topics such as motivation for starting this project and developing of our own hardware and software.

In 2013 we started a research project regarding SOHO networks security called Project Turris. As a part of the project we developed our first open-source SOHO router for analyzing malicious network traffic. Turris Omnia is a spin-off project from the original project Turris which was available only to Czech Internet users in a relatively small quantity. With Omnia we want reuse all the experience we have got with previous project and bring it to the market.

An overview to a bunch of fails in old code

Explanation of a few common and uncommon python mistakes, alternatives and reasons why those mistakes were made in the first place

If you are maintainer or contributor of an open source project which needs design love, this is the right place!

Everyone who has a project can just quickly present it, show the website and state where they need design help. Either we find a match directly there in the room, or we’ll add it to the Open Source Design job board at http://opensourcedesign.net/jobs/

The goal of this theoretical presentation if to explain how a transaction is replicated when using Galera.

I discuss about what is certification and group communication explaining how it's performed. I also cover the difference between MySQL 5.6 GTID and Galera GTID.

We always say Galera replication in synchronous... is it really ? Always ? For every steps ?

What are the caveats of such replication ?

After this presentation, the audience should be comfortable with terms like Brute Force Abort, Flow Control, Local Certification Failure... and now what does virtual-synchronous mean.

The plan is to demystify this technology with easy illustrations and analogies.

The goal of this theoretical presentation if to explain how a transaction is replicated when using Galera.

I discuss about what is certification and group communication explaining how it's performed. I also cover the difference between MySQL 5.6 GTID and Galera GTID.

We always say Galera replication in synchronous... is it really ? Always ? For every steps ?

What are the caveats of such replication ?

After this presentation, the audience should be comfortable with terms like Brute Force Abort, Flow Control, Local Certification Failure... and now what does virtual-synchronous mean.

The plan is to demystify this technology with easy illustrations and analogies.

SASA AG, as public transport operator in major cities in South Tyrol (Italy), has introduced a Bluetooth Beacon infrastructure in their busnetwork in order to make users lives easier. With the app SASAbus users can access real-time passenger information very easily as with the help of the Bluetooth Beacons the exact users' position is selected automatically. To achieve this, the app combines FOSS and OpenData.

Introducing Bluetooth Beacons in our FOSS mobile Application

The first thing to say is that we, SASA AG, are a public transport company in major cities in South Tyrol (Italy) with a strong philosophy of using OpenData and OpenSource to approach our daily challenges. Our mobile application, called SASAbus, provides Real-time Passenger Information, such as information on delays, busnetwork updates, etc. But there we encountered also some issues: to see the real-time departures of the buses, the users had to choose the bus stop manually, because, as everybody knows, in the urban area GPS is not as precise as expected. However, not everyone knows the name of every bus stop, and for people with special needs, for example visually impaired people, it is even harder to type the right bus stop name. To resolve these problems, we decided to put in place a Bluetooth beacon infrastructure on the buses and also on the bus stops. With this infrastructure the application can get information on the exact users' position: where are they waiting for the bus or in which bus are they traveling. Users get the real-time departures automatically when they open the app on the bus stop or directly on the bus, so they know in every moment everything about their trip. This can be for example very important for visually impaired people, because they obviously cannot see where they are: they have either to trust other passengers or their Smartphones. We released the entire source code of our FOSS app under the GPLv3 license and also the beacons' IDs (Creative Commons) in order that everything can be used by other programmers to create some beautiful apps.

I would like to explain you the concept and the work we have done further in my talk.

MoonGen is a scriptable high-speed packet generator suitable to test network devices with millions of packets per second at rates of above 10 Gbit/s. Each packet is crafted in real time by a user-defined Lua script to ensure the maximum possible flexibility. MoonGen is available as free and open source software on GitHub, a scientific paper describing it was published at the Internet Measurement Conference in October 2015.

What is MoonGen?

MoonGen is a flexible high-speed packet generator. It can saturate 10 GbE links with minimum-sized packets while using only a single CPU core by running on top of the packet processing framework DPDK. Linear multi-core scaling allows for even higher rates: We have tested MoonGen with up to 178.5 Mpps at 120 Gbit/s. Moving the whole packet generation logic into user-controlled Lua scripts allows us to achieve the highest possible flexibility. In addition, we utilize hardware features of commodity NICs that have not been used for packet generators previously. A key feature is the measurement of latency with sub-microsecond precision and accuracy by using hardware timestamping capabilities of modern commodity NICs. We address timing issues with software-based packet generators and apply methods to mitigate them with both hardware support and with a novel method to control the inter-packet gap in software. Features that were previously only possible with hardware-based solutions are now provided by MoonGen on commodity hardware. MoonGen is available as free software under the MIT license in our git repository at https://github.com/emmericp/MoonGen.

Using Lua for Networking Tasks

MoonGen is 90% Lua. Each single packet that is sent out is crafted in real time by a user-defined Lua script which needs to process millions of packets per second. There are several challenges that are addressed by MoonGen in order to achieve this. The most important one is multi-threading: all modern NICs are natively multi-core aware and linear multi-core scaling is a must for any modern packet processing app. This talk will address how MoonGen uses a shared-nothing architecture to implement multi-threading via multiple LuaJIT VMs, how the real-time requirements of a packet generator can be fulfilled despite interruptions from the JIT and the garbage collector.

More Information on MoonGen

A scientific paper describing MoonGen was published at the Internet Measurement Conference in October 2015.

TLS and SIP - The Session initiation Protocol - is not a match made in heaven. In the original RFC TLS wasn't really handled well and TLS usage has changed since then, in many RFCs. There are still some issues to handle, as well as ideas about how to apply DANE - TLS verification based on DNSsec. This talk explains TLS, the current usage in SIP, how SIP Outbound comes into play and what's needed in order to proceed with a high degree of interoperability.

Informal discussion on ideas and proposals for future events.

Jetpack brings application containers to FreeBSD

Jetpack is an implementation of the App Container Spec from CoreOS that runs on FreeBSD, using jails for process isolation and ZFS for storage management. I will be speaking about the motivation behind starting a new implementation rather than porting an existing one, about Jetpack's goals, the technology it uses, its architecture and implementation challenges. A quick demo is not unlikely.

FROSTED is an acronym that means "FRee Operating System for Tiny Embedded Devices". The goal of this project is to provide a free kernel for embedded systems, which exposes a POSIX-compliant system call API. In this talk I aim to explain why we started this project, the approach we took to separate the kernel and user-space on Cortex-M CPU's without MMU, the collaboration with the libopencm3 project to provide a high quality hardware abstraction layer and the future goals of the project. Of course there will a demo showing our latest developments: dynamic loading of applications and possibly TCP/IP communication.

Frosted is a free POSIX operating system for embedded systems based on the ARM Cortex-M CPU family. The goal of the project is to provide a POSIX compliant system calls interface in order to be able to run small libraries and applications in userspace. Even if it runs on small systems with no MMU and limited resources, Frosted has a VFS, UNIX command line tools and a HW abstraction layer which makes it easy to support new platforms and device drivers.

In this talk I will explain the approach we took to separate kernel and user space, the design choices we made for the OS internals, our collaboration with the libopencm3 project and our vision on the future of Free and Open embedded systems.

Of course there will a demo showing our latest developments: dynamic loading of applications and possibly TCP/IP communication.

This presentation will involve a few techniques and tricks to reverse engineer multimedia applications, with focus on video decoding.

Reverse engineering is simpler than it looks like: while it's true that there are so many different kinds of audio and video files, there are lots of ways to read them, and make them work with existing software.

During this talk, we will discuss about the ethics, and the motivation behind reverse engineering, and why it is important. We will also analyze a few video technologies, as introduction, and explain the basic hacking techniques, with some practical cases from the real world.

You will be surprised how most techniques do not require any particular tool, except, perhaps, a brain.

From the zealots of the past to the entrepreneurs of today open source has changed how businesses, non-profits, and individuals run software. Over the past 10 years this has expanded into the realm of hardware both in design and manufacturing. In this talk we analyze how we both help and hurt ourselves and figure out how to ensure the best possible outcome.

Free / Libre Software (aka “Open Source”) has become a functional necessity of most 21st century businesses. The promise of “free” software has lead to rapid adoption of new technology and revolutionized past development processes and spurred entirely new models of businesses. The reality is that open source “realpolitik” is now the norm leaving much of the founding ideologies in the past.

Do businesses care about these ideological concerns? Are they used as a marketing/recruiting tool? Can/should the enterprise crowd take a stance on these issues? The focus becomes blurred as one compares software and hardware focused companies.

In this talk we analyze how “Open Source” businesses make money, how they benefit their users, and look at the pragmatic challenges ubiquitous to libre software, open hardware, and selling “support” as a model. In an audience friendly to open source we should be able to look in the mirror and ensure that we aren’t hurting ourselves, our businesses in the pursuit of making a living with the projects we love with the goal being to provide the audience with the insight and information to ask tough questions of each other and be prepared to be happy with the discussion as much as the outcome.

Tarantool is an open source in-memory database and execution platform, based on Lua. The database supports transactions, secondary keys, replication, triggers, and the application server provides an inside-the-database semantics for cooperative multitasking and non-blocking I/O. This presentation focuses on a practical use case: task queue application, using Tarantool as an application server and a database.

The idea of the task queue is that producers put tasks (objects) into a queue, and consumers take tasks, perform them, mark as completed.

The queue must guarantee certain properties: if a consumer failed, a task should return to the queue automatically, a task can't be taken by more than one consumer, priorities on tasks should be satisfied.

With Tarantool, a task queue is a distributed networked application: there are multiple consumer/producer endpoints (hosts) through which a user can interact with the queue.

The queue itself is a fault-tolerant distributed database: every task is stored in Tarantool database and replicated in multiple copies.

If a machine goes down, the state of a task is tracked on a replica, and the user can continue working with the queue through a replica. Total power failure is also not an issue, since tasks are stored persistently on disk with transactional semantics.

Performance of such an application is in hundreds of thousands of transactions per second.At the same time, the queue is highly customizable, since it's written entirely in Lua, is a Lua rock, but the code is running inside the database. This is the strength of Lua: one size doesn't have to fit all, and you don't have to sacrifice performance if you need customization.

Liberating the software running at the lower levels of the hardware we use, either on the main processor or on controllers and peripherals can reveal to be quite challenging. There is a series of (more or less) usual limitations to overcome in the process, each of them being a challenge for free software developers, with the potential of fatally blocking a free software implementation.

This talk will highlight the process of liberating the software running at the lower levels of devices we use. In particular, it will focus on each recurrent limitation that is encountered when freeing a device, with an insight on the process to overcoming them, when possible at all.

Various examples will be shown, drawn from experience liberating mobile devices at the operating system level (with Replicant), at the bootloader level and other devices such as a Chromebook laptop and another laptop's embedded controller.

Finally, the question of the free software replacement's installation process for end users will be mentioned, with positive and negative examples and suggestions for making the process less painful in general.

Status report for the EdgeBSD Project

Status report for the EdgeBSD Project.

LLVM has been around for over a decade and is more popular than ever. Its combination of an easy to use API coupled with high quality documentation has lowered the barrier to compiler development significantly. This has led to a strong adoption of LLVM in many different areas and as a result we can see a wide range of projects using LLVM today. Projects using LLVM cover a large spectrum of domains, ranging from classic C/C++ toolchains to code obfuscation engines and binary translators. The vast number of different projects based on LLVM and the fact that new projects are appearing constantly makes it increasingly hard to keep track of all of them. This talk attempts to summarize the current landscape of projects which are using LLVM in one way or another. The focus of this talk is on projects using LLVM rather than the LLVM compiler infrastructure itself.

An introduction to this track

The organizers of the Desktops DevRoom 2016 would like to thank you and give a warm welcome to our guests

Welcome and info.

The opening talk for the SDR devroom at FOSDEM 2016.

At the opening talk for the software defined radio devroom, we'll introduce the speakers, the projects and the organizers.

During this session, we will see how to use the game framework Babylon.js, and how we can easily create and use 3D content by creating a small WebGL game.

During this session, we will see how to use the game framework Babylon.js, and how we can easily create and use 3D content by creating a small WebGL game.

Discussion with RMS

Tom Marble interviews Richard Stallman on advanced licensing issues in Free Software projects.

Having difficulties with passively testing your infrastructure with old-school supervision software ? Your infrastructure description differs from your monitoring configuration ? Having trouble communicating between ops and monitoring ? Use Salt configuration management to change that.

Once you start using configuration management systems like Salt and describe your infrastructure as code, you can then re-use that description to generate monitoring configuration for various existing monitoring solutions (nagios, shinken, etc.).

You can also use Salt to orchestrate the checks and use other data silos to explore your supervision.

Active checks can be automated by Salt by reusing nagios scripts and munin plugins, collect the data in Graphite and explore them by building graphs in Grafana, finally define alerts with tools like graphite-beacon or Cabot.

Adopt Salt and its flexibility, modularity and event bus that will add software glue between your existing applications and help you scale them.

This presentation will be looking at how to solve some scalability issues in monitoring and migrating from traditional tools to newer tools while keeping existing developments.

Open Source Stack used:

• Salt
• Graphite
• Munin
• Shinken
• nagios-plugins
• Grafana
• Debian

Apache Flink is an open source platform for distributed stream and batch data processing. In this talk we will show how Flink's streaming engine and support for native iterations make it an excellent candidate for the development of large scale machine learning algorithms.

This talk will focus on FlinkML, a new effort to bring scalable machine learning tools to the Flink community. We will provide an introduction to the library, illustrate how we employ some state-of-the-art algorithms to make FlinkML truly scalable, and provide a view into the challenges and decisions one has to make when designing a robust and scalable machine learning library.

Finally, if time permits, we will demonstrate how one can perform some interactive analysis using FlinkML and the notebook environment of Apache Zeppelin.

I talk about how I (ab-)used Perl to help me write modules for which I was too lazy and impatient to write them myself, and how this hubris came before "the fall"

Minio is an Amazon S3 compatible object storage server written in Go and released under Apache License v2. Original prototype was written in C++ with JavaScript extensibility, amongst other choices including Rust, Haskell, C with Guile and C with Python. This talk touches upon specific reasons on why Go was chosen over others. Then further dives into 1 year of real world experience of implementing a storage system in Go.

• Minio project goals
• Go or no Go
• Go tooling
• Packaging modules and dependency management:
  • Limitations of go-get
  • Vendorization
  • Why not gpm (like npm)?
• Linking with external non-Go libraries
• Error handling
• Portability
• Developing a beautiful front-end (both for console and web UI)
• Closing comments

This talk will take a look at a year of development on GNOME Builder by it's primary author. We'll cover tips and tricks to get the most out of the application. Additionally, we'll discuss where the project is headed and how you can help and define it's future.

GNOME Builder has had tremendous development over the past year. It is helping define the design and implementation of GNOME and Gtk-based applications. Learn about where we are pushing the platform and how you can help or take advantage of this. Whether your language of choice is C, C++, Python, Vala, JavaScript or more, we're adding features to make your life easier and hope to create a platform for us all to create great software in an environment that is well-designed, functional, and beautiful.

We will start off with an intro to the GNU Radio Companion, graphical flow graph design and how to add your own blocks. Next, a number of recently added features are presented, including advanced XML features, bypassed blocks, embedded python blocks, custom run commands. We will also look into current development and discuss plans for future versions.

OctaForge is a permissively licensed open source cross-platform (Linux, FreeBSD, Windows and OS X, and possibly other platforms) 3D game engine based on the well known Cube 2/Tesseract engines, While Cube 2 and Tesseract engines were created mainly for the games they power, OctaForge aims to provide a framework for game development.

In my talk I will cover the design of the engines OctaForge is based on as well as design of OctaForge itself, the challenges I faced during its development and the challenges I'm still facing as well as the future direction of the project.

And to make things more interesting, I'll show some demos as well.

OctaForge is a permissively licensed open source cross-platform (Linux, FreeBSD, Windows and OS X, and possibly other platforms) 3D game engine based on the well known Cube 2/Tesseract engines, While Cube 2 and Tesseract engines were created mainly for the games they power, OctaForge aims to provide a framework for game development.

In my talk I will cover the design of the engines OctaForge is based on as well as design of OctaForge itself, the challenges I faced during its development and the challenges I'm still facing as well as the future direction of the project.

And to make things more interesting, I'll show some demos as well.

SAGA (System for Automated Geoscientific Analyses) is an open source geographic information system (GIS) used for editing and analysing spatial data. It includes a large number of modules for the analysis of vector (point, line and polygon), table, grid and image data. Among others the package includes modules for geostatistics, image classification, projections, simulation of dynamic processes (hydrology, landscape development) and terrain analysis. The functionality can be accessed through a GUI, the command line or by using the C++ API.

SAGA has been in development since 2001, and the centre of SAGA development is located in the Institute of Geography at the University of Hamburg, with contributions from the growing world wide community.

This presentation will show some of the newer modules of SAGA and how these can be combined to scripts and toolchains to reproduce different steps of an analysis.

Apache MADlib (incubating) is an innovative SQL-based open source library for scalable in-database analytics. It provides parallel implementations of mathematical, statistical and machine learning methods for structured and unstructured data. MADlib also has an R interface for data scientists who prefer to work in R.

In this talk, we will describe the impetus behind creating a SQL-based scale-out machine learning project, review the architecture and implementation, and describe some of the recent functionality added by the Apache community. We will also present the R interface to MADlib, called PivotalR.

Finally, we will discuss the future direction of the project and invite big data developers and data scientists to participate in Apache MADlib, for both fun and profit.

The primary goal of the MADlib project is to accelerate innovation in the data science community via a shared library of scalable in-database analytics.

Many existing analytics products do not scale in a way that makes it convenient and economical to operate on very large data sets, which is a more and more common scenario in this era of Big Data. The methods in MADlib have been designed to take advantage of the shared-nothing, scale-out parallelism offered by modern parallel database engines.

Currently MADlib runs on the following open source platforms: Apache HAWQ (incubating) Hadoop-native SQL Database, Greenplum database, and PostgreSQL. Big Data has also brought about a renewed interest in query optimization, so as these platforms innovate in the area of distributed query performance, libraries such as MADlib can benefit greatly and provide even more significant benefits to research and commercial organizations that want to reason over very large data sets.

Some other key principles driving the architecture of MADlib are:

• Operate on the data locally in-database. Do not move data between multiple runtime environments unnecessarily.

• Utilize best of breed parallel database engines, but separate the machine learning logic from database specific implementation details.

• Foster open community development, including active ties to academic research.

We look forward to presenting this topic at FOSDEM’16!

WebAssembly is a tale of four browser vendors, seeking new languages and capabilities while staying fast, secure and portable. The old JavaScript wizard still has many spells under its belt, but it seeks a companion on its quest to reach VM utopia. WebAssembly is that companion.

In this quest, mad alchemist Dan and jester JF will detail their exploration of LLVM-land. You’ll get to witness firsthand their exploration of ISel and MI, hear of their wondrous encounter with MC, and gasp at the Spell of Restructuring wherein SSA+CFG is transmuted into regs+AST. Will our adventurers conquer the Target and capture the virtual ISA?

Join us in this exciting tale to which you are the hero!

While Haiku uses its own native graphical interface and GUI toolkit, and aims for maximum GUI coherence, not being a mainstream OS in the FLOSS ecosystem means porting applications is necessary to having a fully usable system more quickly. We'll look at the current status and limitations of ported GUI toolkits on Haiku, and expected roadmaps.

Haiku's graphical interface is different from most FLOSS OSes around, as it does not make use of X11, which has consequences on the availability of various known GUI toolkits. Indeed, most of them are quite dependent on X11 features, or sometimes lack features which are already present in X11, leading to applications improperly bypassing the toolkit. Also, since the native toolkit is only available as a C++ API, further concerns arise when porting them over. And the limited number of developers also means some old widespread toolkits aren't yet available while more recent ones already are.

Nevertheless, the advent of proper package management and a port system recently accelerated Haiku's development, leading to many new ports.

We'll detail which toolkits are usable, and what's missing.

GNU Radio comes with myriad tools that make development easier. This presentation will highlight the most useful tools and show how hackers can smoothly and without much effort start hacking DSP or radio applications, skipping the overhead of writing boilerplate code or setting up development environment.

This presentation will cover the usage of: - The GNU Radio LiveSDR - PyBOMBS (or whatever its successor is) - gr-modtool - Editor plugins - Graphical widgets

etcd is an open source distributed consistent key-value store written in Go. It has become a mature cornerstone of a variety of distributed systems for networking, service discovery, configuration management and load balancing. This talk will describe etcd, its history, its new V3 API, and some of its production use cases. It will also dive into some of the ups and downs of using Go to develop software that powers some of the most reliable distributed systems.

The ability to run resilient, hyperscale infrastructure today means running it in a distributed way. But building distributed systems is complex and can be a challenge because one of the essential elements includes removing any single point of failure. The answer? Powering these systems with a reliable, distributed database, designed to ensure your infrastructure stays up and running even when individual servers fail.

etcd is an open source distributed consistent key-value store written in Go that was introduced by the team at CoreOS. Since its release in 2013 it has become a mature cornerstone of a variety of distributed systems for doing networking, service discovery, configuration management and load balancing. This talk will describe etcd, its history, its new V3 API, and some of its production use cases. It will also dive into some of the ups and downs of using Go to develop software that powers some of the most reliable distributed systems.

Perl 6 is generating a lot of positive buzz. Envious of the awesome features in other languages? You'll likely find them in Perl 6. The Perl 6 developers took the time to carefully integrate features that developers actually need and they've created a language with a great balance between evolutionary and revolutionary. Come find out what the excitement is all about.

Open source engines for trip planning are growing in popularity. We are part of the movement by creating our own engine and a framework for the development of new algorithms.

Tempus focuses on planning trips that involve all possible transport modalities, mixing private and public modes as well as shared vehicles, and on requests with multiple objectives.

It relies on well-known open source components and standards like PostGIS, QGIS, WPS, boost graph and offers tools for importing routing data from various sources, including OpenStreetMap.

This presentation will illustrate the overall modular architecture of Tempus built around a C++ core and will detail recent additions to the engine, like the integration of Contraction Hierarchies, thanks to industial parternships.

At FOSDEM 2013, leading developers of free real-time communications software dared to get up on stage and ask the question "Can we replace Skype, Viber, Twitter and Facebook?". Was this the right question and how does it relate to free software development today and in the future? Pocock talks about what has changed since then and where things are going in this domain in the year ahead, especially with the emergence of WebRTC and the ubiquity of browsers that support it and the opportunities this has created for the world of web development and interaction with other open systems.

Can you imagine a world where phone communication works with all the benefits of email (but without spam)? Per-minute charges eliminated, flexibility for developers to customize the experience with standard scripting languages like Python or JavaScript and organizations of any size able to assert their identity and brand securely using SIP and XMPP addresses?

Is this a worthwhile vision? What do each of us - developers, sysadmins and end users - need to do to make it happen? What will be the alternative outcome - for both society in general and fans of free technology in particular - if we stand back and allow proprietary solutions to run rampant?

This session will survey some of the free software solutions that exist today and ways you can participate in their improvement and deployment to help realize this vision.

Routing: A view from my local topography on routing technology and Free Software.

Routing is a seemingly simple field, but with many details as you dive in. This talk intends to give an overview of some of the core methods used in routing, and their uses (which can extend beyond routing), benefits and trade-offs. It intends to tie this in with an overview of Quagga, a Free Software routing software suite, and explain how Quagga can be used to build solutions to routing and other networking problems.

Routing: A view from my local topography on routing technology and Free Software.

Routing is a seemingly simple field, but with many details as you dive in. This talk intends to give an overview of some of the core methods used in routing, and their uses (which can extend beyond routing), benefits and trade-offs. It intends to tie this in with an overview of Quagga, a Free Software routing software suite, and explain how Quagga can be used to build solutions to routing and other networking problems.

Once Upon a Time, Linux distributions were the "center of the universe" for free and open source software. If you wanted to reach users with your project, the best path to do so was to have your software packaged for the "major" Linux distributions of the time. Today, the world looks a lot different with language-specific package managers, microservices and containers, and so on. What's the role of Linux distributions in today's open source world, and where do we go from here?

Once Upon a Time, Linux distributions were the "center of the universe" for free and open source software. If you wanted to reach users with your project, the best path to do so was to have your software packaged for the "major" Linux distributions of the time. Today, the world looks a lot different with language-specific package managers, microservices and containers, and so on. What's the role of Linux distributions in today's open source world, and where do we go from here?

A quick hello and welcome to the 2nd Ruby devroom. We'll talk about the goal of this devroom, what makes it different from other Ruby events. We'll talk a bit about Ruby Belgium, thank our sponsors and get the show started for the day!

A quick hello and welcome to the 2nd Ruby devroom. We'll talk about the goal of this devroom, what makes it different from other Ruby events. We'll talk a bit about Ruby Belgium, thank our sponsors and get the show started for the day!

By now most people have either created their configuration management solution or are just embarking on this journey. This talk will discuss how to take configuration management to the next level with orchestration and modelling.

This talk will go over how and why people are moving from a machine centric view to a service oriented view of deployments and how you can leverage the knowledge and tools used at the machine level to expand to the scale-out, service oriented architecture. This talk will also cover and compare solutions that are both specific to a single configuration management product and others that are agnostic to the underlying configuration management tool

We all know how good horizontal scaling is. We also know that PHP is born single threaded, and therefore it’s not the best available tool for heavy processing or intensive batch jobs. In this talk we’ll see how to get through these shortcomings, achieving parallel processing through native solutions such as Process control functions and POSIX functions, but also exploiting more recent techniques such as message queues and nonblocking I/O. We’ll cover a wide range of examples from real world applications, and dealing with tools such as Gearman, RabbitMQ, ReactPHP and Icicle.

.

Bigtop is an Apache Foundation project for Infrastructure Engineers and Data Scientists looking for comprehensive packaging, testing, and configuration of the leading open source big data components.

Insights into bootstrapping and automation of the packaging process on ci.bigtop.apache.org will be given. Special focus is on the use of docker containers for isolating and scaling the build processes.

Some aspects of the challenges of porting the bigtop distribution to other platforms will be covered, too.

Another focus of the talk will be on deploying Bigtop components using the supplied puppet scripts. Included are life deployment demos into docker containers featuring different Big Data scenarios.

REPLACEMENT for "Building open source with open source" by Nicolas Schiper

The demand for managing a large amount of data in a scalable yet reliable and cost-effective way has became more and more relevant in this day and age. Ceph, a software-defined storage, provides an original solution for this problem and guarantees a resilient and self-healing way for managing large amount of data up to the Exabyte level. In this session I will talk about a new feature introduced in oVirt 3.6 which provides the ability to integrate with Red Hat Ceph storage using Cinder, a storage service used mainly for OpenStack. This integration reveals new opportunities and tools for storage management in a scalable and virtualized way and also opens the door for interesting future integrations with other storage providers.

In this session I will describe how oVirt, an open source virtualization management platform, has extended and elevated its storage virtualization management capabilities by integrating with Cinder, a storage service, to manage resources from the Ceph Storage. oVirt 3.6 revolutionize the way it manages virtualized storage to be much more scalable and flexible, and opens the door for future integrations with well known storage providers such as NetApp, EMC, HP and more.

Who doesn't like tiny handheld gaming devices that you could download free - or even, create your own - games for? The Arduboy is this exact device, low-cost, small and incredible fun to play with! Playing games is one thing though, so I set out on creating a Web IDE to make it even easier to make, hack, remix & share games with other Arduboy-fans!

The Arduboy is a tiny pocket-size gaming device, based on the Arduino Leonardo, with some extra buttons, a screen and a buzzer - and the perfect platform to learn the ropes of both hardware hacking and games development in a fun & approachable way. To make games creation even easier, I've created an IDE, entirely based on web technologies, that helps lowering the entry barrier by making mundane and complicated stuff (such as creating and animating image sprites) a breeze on the Arduboy, putting the fun back into games creation and helping people get started with games creation.

I will be presenting the Arduboy and the open source beta Web IDE I've been working on that makes creating, flashing, sharing games a breeze!

Mailing lists are the bedrock of many open source software projects, and have been so since the early days of the Internet. However, mailing lists can struggle to compete with code collaboration tools like Gerrit and Rietveld, many of which offer features such as integration with automated testing tools and patch tracking. How can such features be integrated into existing, mailing list-based projects like the Linux kernel or DPDK? The presenter reports on the ongoing work around the widely-deployed 'patchwork' tool to do just this.

Tracking of patches between development mailing lists and automated testing tools can be accomplished using patchwork. patchwork provides a web interface for patches submitted to mailing lists and presents them alongside any comments. patchwork also supports the tracking of the state of patches, be they Accepted, Rejected or Under Review. By design, patchwork is not intended to replace mailing lists but rather supplement them: these features are entirely optional, but where used can help ease the burden on maintainers by removing the need to perform tedious, time-consuming and low-value tasks like manual sorting. patchwork is already widely deployed for many projects, and instances can be found on kernel.org, dpdk.org and openembedded.org, to name but a few. There are also many projects, including Open vSwitch and QEMU, that can be found on ozlabs.org, which is maintained by the original author of patchwork.

This talk outlines the ongoing work to supplement development mailing lists with web-based workflows using patchwork. We demonstrate how features such as continuous integration support, automated patch and series tracking and a vastly expanded API help position the combination of the Mailing List and patchwork as a viable, feature-competitive alternative to tools such as Gerrit or Rietveld. We also detail some of the complexities of structuring the inherently unstructured data found on mailing lists. How do I identify a series of patches, for example? How do identify a reply to a patch? How do I identify a patch itself?

This talk be of particular interest to testers of open source, mailing list-based projects such as the Linux kernel, QEMU, DPDK or Open vSwitch. These users will be able take advantage of features like support for continuous integration servers and series tracking to develop automated, distributed testing infrastructures. Communities like OpenStack have shown that such infrastructures are critical for delivering software faster while reducing risk and maintenance cost. Such an infrastructure is currently being developed for the DPDK community, and it is easy to envision a similar roll-out for other projects with similar requirements.

It will also be of interest to the developers of these projects. These developers can already use patchwork as a tool to track patch backlogs, maintain personal TODO lists, or just browse submissions via a web UI/XML-RPC API. However, the new features provide these users with functionality that can help automate even more of the tedious yet necessary overhead tasks.

The Unitary Patent is the third major attempt to legalize software patents in Europe. The European Patent Court will become the Eastern District of Texas when it comes to software patent disputes in Europe. As happened in America, the concentration of power will force up legal costs, punish small European innovators, and benefit large patent holders.

The Unitary Patent is the third major attempt to legalize software patents in Europe. The European Patent Court will become the Eastern District of Texas when it comes to software patent disputes in Europe. As happened in America, the concentration of power will force up legal costs, punish small European innovators, and benefit large patent holders.

The second attempt to codify EPO software patents failed in 2005, after many years of debate, the directive was rejected under the request of large multinational corporations, that prefered the creation of a central patent court over the debate on software patents.

The Unitary Patent Court is a deeply flawed project, as it is based on dubious economic studies, a rogue patent office (the EPO), a court stuffed with biased patent specialists, and is out of parliamentary control. It will participate to global patent warming, rubberstamp software patents, multiply the number of patent trolls, and increase the entry cost for defendants, which is already out of reach for many of us.

This presentation will describe the Apertium project (http://www.apertium.org). Apertium develops a free/open-source platform for machine translation and language technology. Apertium also develops data for many languages, with a focus on lesser-resourced and marginalised languages, but also develops data for larger languages. The platform, including data for tens of language pairs, a translation engine and auxiliary tools is being developed around the world, both in universities and companies and by a growing numbers independent free-software developers. There are currently 40 published language pairs within the project (including a number of "firsts" — for example Spanish—Occitan, Breton—French, Basque—Spanish, North Sámi–Norwegian Bokmål and Kazakh–Tatar among others), and many more in development.

The talk will be given by Dr. Francis M. Tyers. Dr. Tyers has been involved in the field of free/open-source machine translation for nine years; he completed his PhD at the Universitat d'Alacant, and now works as a postdoctoral researcher at UiT Norgga árktalaš universitehta. He has published over 30 articles related to machine translation, and has been involved in the teaching of several courses on machine translation. He is secretary of the ISCA SIG SaLTMiL (Speech and Language Technology for Minority Languages), the ACL SIG SIGUR (Uralic Computational Linguistics) and the Apertium project.

As the power pendulum swings towards developers and open source, from sys-admins and proprietary software, respectively, Linux Distributions are faced with a challenge. How do they get more relevant to the new power brokers?

This talk will discuss the work taking place in the Fedora, CentOS, and Red Hat EL communities to address these challenges.

Long Description

As the power pendulum swings towards developers and open source, from sys-admins and proprietary software, respectively, Linux Distributions are faced with a challenge. How do they get more relevant to the new power brokers?

Over the years, application and web developers have made it clear they are uninterested in packaging their applications if it requires them to do things beyond their normal languages and tool-chains. They are also not particularly interested in consuming their dependencies via distribution packaging tools if it requires a lag in availability, the developers packaging the libraries, and/or learning the packaging software tools beyond the most rudimentary level. Developers have also made it clear that the way software is packaged, normally targeted at production installations, is very cumbersome when using it for development (e.g. the perennial 'setenforce 0').

Many people interpret the above as "developers don't care about security or the trustworthiness of their dependencies." However, this is a mistake. Developers do not ever want to be the person listed as the problem when a major breach occurs. On the flip side, their "bosses" (actual bosses, software communities, professors, etc) set and enforce deadlines that do not allow for the time to muck about with things not directly related to their application development.

What can distributions do? Well, how about they stop providing a distribution. Instead, they can provide an operating system and a set of content. Where the "things" found in the operating system part are packaged in the traditional manner and provide all the traditional guarantees. However, the "content" is provided in the native formats developers are used to and the guarantees, where possible, are provided through other mechanisms.

This talk will discuss the work taking place in the Fedora, CentOS, and Red Hat EL communities to address these challenges.

Etnaviv is a FOSS implementation of a graphics driver for the Vivante embedded GPU IP cores. This talk will cover where the etnaviv community has come from, the motivation behind writing a free software replacement of Vivantes own driver and what we intend to do in the future.

Signal Intelligence Challenges are a great and fun way to get students interested in communications and SDR. We want to report from our previous experience gained from organizing the IEEE Signal Intelligence Challenge in 2014 and 2015. This includes our educational goals as well as practical concerns when organizing such an event, ranging from frequency regulations to giving students access to SDRs and the required software tools.

Yocto project has been used at Open-RnD for building a number of IoT related products. The talk will go though the details of integration of Poky build system and OpenEmbedded layers into 3 projects carried out at Open-RnD:

• an antonomous parking space monitoring system
• a distributed 3D steroscopic image acquisition system
• a gadget for acquisition of metabolic parameters of professional athletes

The presentation will approach to building software, automation and upstreaming of fixes.

Open-RnD is a small software company from Łódź, Poland. We have started using Yocto/Poky in late 2013 as a better alternative to in-house build system. Since then, we have successfully implemented a number of projects based on Poky. The presentation will go through the details of 3 projects that cover a diverse range of applications:

• an autonomous parking space monitoring system (ParkEasily)
• a distributed 3D stereoscopic image acquisition system (Ros3D)
• a gadget for acquisition of metabolic parameters of professional athletes (Sonda)

We only use widely available hardware platforms such as BeagleBone Black, Raspberry Pi, Wandboard or Gateworks GW5400 (not as widely used as the previous ones, but still fully supported), hence all the points made during presentation are directly applicable by professionals and hobbyists alike.

Open-RnD

Open-RnD is a small company. The embedded team if even smaller, currently consisting of only 4 people. Since we have rather little resources for maintaining of software, as much work as possible is pushed upstream to Yocto, OE, libraries and packages we depend on (swupdate, Vala, rabbitmq-c, sparts, edts) or tools (ex. jhbuild).

Poky/OE methodology

The presentation will cover out methodology of staying close to the upstream. Normally when starting a new project we will base it on Poky master instead of relying on, so called, stable releases (the same approach is used for other layers). This has a number of advantages:

• you get the latest versions of libraries (with fixes & bugs alike)
• it's easy to upstream fixes

Our practice is to maintain a mirror of upstream repositories. The mirrors are synced every couple of days by our staff members. The branches are then periodically merged into project related branches. Systematic merges help to reduce the number of commits that we need to look at, so the whole effort of merging & reviewing is rather limited. Effectively very few software packages are used by the projects, so most of the commits have no or little effect on the stability of the software stack.

Jenkins

We'll also cover a very simple Jenkins integration wrapper that can be utilized for building Poky based projects.

Development methodology

We'll give some tips on how we think is convenient to develop software so that the integration with any build system is smooth. Specifically we'll emphasize the role of tools such as jhbuild in the whole process and provide tips on how to utilize them efficiently.

ParkEasily

The project's goal is to build a system for autonomous parking space monitoring. This is used for feeding a mobile client application with information on parking space availability within a given area and allows us to direct users to the closest available car park.

The project is composed of a server backend written in Erlang (hoping to be able to present a couple of issues at Lambda Days in Krakow), an intemediate AMQP broker (RabbitMQ) and device endpoints that integrate with parking gates or tap into industrial video streams.

The presentation will cover our first prototyping steps on Raspberry Pi and a later implementation on BeagleBone Black. We'll highlight the aspects of layer organization, and how our methodology of working with Yocto upstream applies in this case.

It will also go through number of fixes related to building of bootable SD card images were implemented for the wic tool. The upstreamed fixes allowed for building a bootable SD images for BeagleBone Black out of the box.

The presentation will focus on layer organization, and give tips on maintenance of custom application layers. We'll also introduce our open-rnd branded distribution within meta-openrnd layer and justify why we have done so.

Since the project covered some aspects of 3G/4G and VPN connectivity, we'll cover that providing examples how to tie that nicely with systemd and udev at Poky level.

Sonda

We used Yocto to implement a mobile base hub and recharging station for IoT gadgets. The base hub was responsible for downloading of any unsent data from the devices. We'll give details on implementing a service that needs to react to external devices appearing on a USB bus.

Since we did a low level integration with a MQTT broker. This part will also cover why it is important to have a working build system for software packages before starting with Poky and problems we identified with libmqttv3c library from Eclipse's Paho Project. Due to limited compatibility with Glib's main loop approach of the libmqttv3c library, we have decided to implement a separate library based on embedded version of the original MQTT library. The library requires cleaning up and will be pushed to our github.

Ros3D

The project is aimed at building a system for acquisition of stereoscopic video for professional filmmakers. The project is partially funded by a grant from the National Centre for Research and Development.

The project is the most demanding compared to other two. The talk will focus on do's and don'ts of layer organization and custom distributions.

Specifically we have implemented a layering scheme that nicely separates the base layers, the BSP layers and the application layers. This allows for plugging in a different platform at the BSP level to keep the development cycle going even when the target hardware is not available.

A tour through some lesser known features, subcommands, and recipes for doing interesting things with ZFS, presented by the co-author of "FreeBSD Mastery: ZFS"

ZFS is well known for being a rock solid storage system with a plethora of features. Yet, most users are unaware of just how powerful ZFS is. ZFS is so fundamentally different from other file systems that new and interesting things are possible. This presentation will demonstrate a number of very interesting configurations that sysadmins, developers, and others may find very useful.

The presentation starts with a very brief summary of ZFS's features, then immediately delves into interesting hacks. * Script-ability of ZFS * Abusing properties and inheritance * Mount point trickery * Delegation hacks and recipes * Applying limits to users and containers * Using ZFS to juggle development workflows * ZFS replication for conference attendees and road warriors * Lesser known subcommands * Abusing zdb * Storing configuration in ZFS

To be followed by an overview of recent and upcoming developments in OpenZFS, and then questions.

This talk will discuss the representation of objects in dynamically-typed languages like Ruby. From the naive hash table used in ruby 1.8.7 to the highly optimized and type-specialized representation, we will take a look at a few common representations for objects with a dynamic number of fields. Advantages and drawbacks will be discussed and in particular the behavior of objects accessed concurrently. Would you expect instance variables to disappear? Or that writing to them would have no effect? If not, come and see why it could happen, and what can be done to fix it and at what cost!

JRuby+Truffle is a high performance implementation of Ruby being built as an open-source project at Oracle Labs. It uses state-of-the-art research techniques for writing interpreters and dynamic compilers that allows it to be both significantly faster and simpler than any other implementation of Ruby. It is built on top the of Truffle framework which provide an Object Storage Model. We present a solution to make it behave correctly under concurrent access.

Free Java 2016 Welcome - Sunday

The Eclipse IDE a open project developed by a divers group of developers. In this talk the Eclipse IDE project is presented. Which tools are we using? Which developments are we doing, etc? How are we executing our texts and how can you hack on Eclipse and contribute it back to the project.

The audience will learn about the project, what we are doing and how to contribute.

Genode is a component-based operating system developed from the ground up to counter most security issues that plague us today, like spyware, viruses, and zero-day exploits. It combines microkernel technology, capability-based security, and virtualization with a unique component architecture. Developed over the course of 8 years, the project has finally evolved to a state where its developers use it as their desktop OS. The talk will give an introduction into Genode and demonstrate its unique takes on desktop computing.

In the free-software community, there is very little competition that challenges the predominant POSIX-based operating systems like Linux and FreeBSD. It's a universal truth that the creation of a new general-purpose operating system from scratch is infeasible due to the enormous amount of work needed to develop device drivers, libraries, and applications. Since most users seem to be content with the current POSIX-based state of the art, good arguments would be needed to justify such an effort.

Security and privacy are such arguments. In times when threats like identity theft, the leakage of personal information, business espionage, spyware, and even targeted attacks become prevalent, the current generation of commodity OSes remain inherently vulnerable to zero-day exploits and privilege escalation, and leave the end user largely unprotected.

Genode is a new operating-system architecture that promises to prevent most classes of security problems by design. Genode-based systems are created out of surprisingly simple primitives: Each program runs in a dedicated sandbox and gets granted only those rights and resources that are needed for its actual task. Programs can create and manage sub-sandboxes out of their own resources, thereby forming hierarchies where policies can be enforced at each level. Thanks to this rigid regime, the attack surface of security-critical functions can be reduced by orders of magnitude compared to contemporary operating systems.

After 8 years of development, the project has reached a state where a small group of enthusiasts use it as their primary OS. This was made possible by the virtue of embedding a wealth of open-source projects as components into the new system. For the use as desktop OS, Genode integrates Qt5, VirtualBox, Intel KMS, the GNU utilities, the Linux USB stack, the Intel wireless stack, Rump kernels, and a number of custom components into a completely new system composition.

The talk will first introduce the basic concepts behind Genode, contrasting its architecture to current-generation OSes. The second part of the talk will demonstrate how Genode approaches desktop computing and how it is used as day-to-day OS on the speaker's laptop.

Are you interested in gaining some insight in the running time of the build process of your project? Buildtime Trend is an Open Source application that collects timing data from a build process, currently Travis CI, and uses this to create charts to visualise trends of what's happening during a build. We'll explain how it works, and how you can set it up for your project, concluding with a demo that shows the charts and metrics on the dashboard.

The Buildtime Trend project started in an urge to find the cause of an unstable build process. A first version was a collection of Python and Bash scripts that generated timing data and produce a simple chart showing duration of different parts of a build process. In the last few months these simple scripts have evolved into a Heroku hosted service that gets timing data from the log file of Travis CI build job. The service is automatically triggered when a build is finished.

The timing data that is gathered by the service is used in a dashboard with a series of charts and metrics. It shows data like build time duration, failed and successful builds. It is also possible to select different timeframes, and to filter on specific build job parameters like branch name and language version.

Currently, the service can process Travis CI build logs, but in the future, other CI platforms will be supported as well.