FOSDEM welcome and opening talk.

Welcome to FOSDEM 2015!

Karen Sandler, Executive Director of the Software Freedom Conservancy, will discuss the peculiar tension in the intersection of free and open source software and corporate interest. Working in free software often triggers a complicated set of allegiances. When tricky situations arise how do developers decide what their priorities are? As a community how do you know whether a contributor is advocated the best for the project of the best for their employer? How much can governance help? And at the end of the day, how do the ideological components to these projects really play out? And how should they?

This is a very confusing area in free and open source software communities. I will use specific examples from a few different free software communities to illustrate the current state of ambiguity. This presentation will shed light on the situation and propose proactive solutions.

This presentation will summarize the status and current roadmap of the EdgeBSD Project, which started from the NetBSD codebase in mid-2013. The aims at broadening and community development around NetBSD thanks to a tentatively more modern development workflow, based on Git.

We, the organizers of the the GraphDevroom, will give a warm welcome and a review on the graphy year 2014.

We, the organizers of the the GraphDevroom, will give a warm welcome and a review on the graphy year 2014.

Many professional users at broadcasters and other institutions want to use FOSS but at the same time in the eyes of others FOSS doesn't get the respect it deserves for a variety of technical and social reasons. This presentation will look at some examples of how this can be improved using examples from the speaker's experience where FOSS is used for mission critical uses, mostly in compression but also in other areas.

We describe a new free software project, called CGen [name might change], a C code generator with support for Common Lisp-style macro expansion. It is based on a new S-Expression based Syntax for C (and C-like languages) which is transcompiled to C (or C-like) code. Our code generator supports the simple and efficient management of variants, ad hoc code generation to capture reoccurring patterns, composable abstractions as well as the implementation of embedded domain specific languages by using the Common Lisp macro system. We demonstrate the applicability of our approach by numerous examples from small scale convenience macros over embedded languages to real-world applications in high-performance computing.

After successful presentation at ELS in 2014 we decided to polish our research prototype and make it available as free software.

For a full description we would like to refer to the attached paper, which was accecpted and presented at ELS this year.

Software development rarely has "spare" time, which often forces developers to stick to the tools they already know. Having any sort of learning curve can be a barrier to entry for debugging and performance tools, even when the payoffs are worth the time invested learning new tools. The Linux Tools Project aims to improve the state of C/C++ development on the Eclipse IDE by integrating popular tools, such as Valgrind. This integration allows developers to maintain an environment they're familiar with, yet leverage new development tools.

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

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

Quick overview of the Linux Tools Project Introduction to the Eclipse Valgrind plugin Demonstration of * Memcheck * Massif * Helgrind * Cachegrind * Eclipse Platform specific integrations (Error markers, Problems View) * Simple Auto-correction for common Memcheck/Helgrind problems * Support for execution on remote targets

Possible improvements to Valgrind tool

Challenges faced regarding Valgrind tool

Now that expressive infrastructure as code models nearly everything in the datacenter, we have a different problem — weeding out bad infrastructure code! Quality coding practices aren’t new but most operations teams are learning them for the first time. This talk will offer guidance on how to identify various facets of infrastructure code quality. Though examples are offered in the Puppet DSL, this talk is designed for anyone using configuration management software to manage infrastructure and applications.

Now that expressive infrastructure as code models nearly everything in the datacenter, we have a different problem — weeding out bad infrastructure code! Quality coding practices aren’t new but most operations teams are learning them for the first time. The Puppet Forge’s product manager Ryan Coleman will discuss what he’s learned from the thousands of examples available on Forge. Though examples are offered in the readable Puppet DSL, this talk is designed for anyone using configuration management software to manage infrastructure and applications. No knowledge of Puppet is required to learn from this session.

Ryan has been knee-deep in infrastructure code for 4 years, starting as a user of Puppet at Penn State and moving on to manage the Puppet Forge at Puppet Labs, a shared repository for great (and not so great) infrastructure as code written in the Puppet DSL. He’ll cover how to identify various quality characteristics and why they matter in your day to day. It’s not just about conforming to a style and aligning your braces! After this talk, you should be equipped to have a conversation with your team about how to collectively improve the code base and reduce long-term maintenance.

Introduction to the Perl devroom.

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

Python and PostgreSQL, two tools we like to use for our projects but do you know everything about them? The talk will give an overview of psycopg2, SQLAlchemy, Alembic and PL/Python, these libraries can be used with PostgreSQL to improve the life of the Python developer.

Python and PostgreSQL, two tools we like to use for our projects but do you know everything about them?

The talk will give an overview of psycopg2, SQLAlchemy, Alembic and PL/Python, these libraries can be used with PostgreSQL.

• psycopg2, the well known connector, this basic component is really useful, well documented and battle-tested and used by the most famous toolkits of the Python ecosystem.
• SQLAlchemy, a Python SQL toolkit and Object Relational Mapper, you can use this library to create your models and interact with them.
• Alembic, a lightweight database migration tool for usage with SQLAlchemy, allows to create some migration scripts for your project.
• PL/Python, a procedural language for PostgreSQL, allows to write functions in the Python language.
• MultiCorn, a Foreign Data Wrapper in Python

Please note that this talk replaces one entitled "TaskFlow: State Management Framework" which was to have been given by "Vishal Yadav". Regrettably "Vishal Yadav" has withdrawn from the event on account of an illness. We wish him/her a speedy recovery.

What is the current status of Allwinner support in upstream u-boot and the kernel, which SoCs are supported, and which features (sound, video, etc.) are supported ?

The linux-sunxi community has been slowly but steadily working on getting Allwinner SoCs like the A10 supported in upstream u-boot and the kernel.

This talk will present the current status of Allwinner support upstream. Which SoCs are supported and which ones are not (yet) supported ? Which blocks if the supported SoCs are supported, and which are not ? Why are some SoCs / blocks not supported, and what are the plans to get them supported ? This are some of the questions this talk tries to answer.

Debian GIS is a project with the goal of making Debian the best distribution for Geographical Information System applications.

OSGeo live (live.osgeo.org) is a self-contained bootable dvd, usb thumb drive or virtual machine based on Lubuntu, that allows you to try a wide variety of open source geospatial software without installing anything. It also contains a set of uniform documentation (description and quickstarts) to guide people around the different projects.

Even though OSGeo live is based on the packages in Debian, both projects diverted and where OSGeo live managed to get a large (100+) community of contributors, progress in Debian GIS was stalling. Recently however, a new wind is blowing in Debian GIS (among others with the Debian pure blends initiative) and many changes from OSGeo live are being incorporated back into Debian.

Apart from presenting both projects I will highlight some problems people encounter when they would like to add their package to Debian GIS, and how Debian pure blends try to solve this.

This talk will provide you key technical highlights about Sphinx as a full text search engine from internal architecture overview to scalability and high availability strategies.

Detailed talk line up: - What is Sphinx - Internal architecture - Key full text and non-full-text functionality - Application integration - On-disk vs Real-time indexes. - Performance tricks - Scalability and high availability

CPAN is Perl's killer feature. The information available in CPAN is massive, but without a proper API, it's difficult to work with. MetaCPAN provides this API, and MetaCPAN::Client provides the ability to work with the API in a sophisticated and comfortable way.

Suppose you want to import virtual machines you already have into oVirt to enjoy a features-rich open sourced management system. You will soon figure out that the conversion of virtual machines running on different hypervisors or managed by different management systems into oVirt is not an easy task. The next major version of oVirt is going to introduce an integrated process that will simplify import of virtual machines not being managed by oVirt into oVirt. This session gives a heads up for the feature: we will go over the design and see how it solves issues that we had before to provide better way for import virtual machines to oVirt.

Until now from oVirt one could only import virtual machines (VMs) that were managed once by oVirt, either VMs that were exported from oVirt or VMs that reside on storage that was attached once to oVirt. In order to import VMs that run on different hypervisors or managed by different tools/management solutions, one had to use external tool, such as virt-v2v, separately to convert the VMs so they will fit to oVirt and then import the VMs from oVirt. This results in a slow, tedious and error-prone process. An important feature in oVirt 3.6 is going to be the extension of import VMs capabilities to provide users with a process that is integrated within oVirt web-admin ui for import VMs from external environments, i.e VMs that run on different hypervisors and managed by different management solutions. We produce a process based on integration with virt-v2v, for import such VMs to oVirt which is better in terms of usability, performance and monitoring. The new process will ease migration of existing VMs into oVirt, encouraging people to have their existing virtual environments replaced with oVirt. In this session we will analyse the problems with the previous process, go over the design of the new one and see how it address the problems we used to have, producing a better way for migrate existing virtual environments to open source virtualization platform.

Apache Flink is a general-purpose platform for batch and streaming distributed data processing. This talk describes how Flink’s powerful APIs, iterative operators and other unique features make it a competitive alternative for large-scale graph processing as well. We take a close look at how one can elegantly express graph analysis tasks, using common Flink operators and how different graph processing models, like vertex-centric, can be easily mapped to Flink dataflows. Next, we get a sneak preview into Flink's upcoming Graph API, which further simplifies graph application development in Flink. Finally, we show how to perform end-to-end data analysis, mixing common Flink operators and the Graph API, without having to build complex pipelines and combine different systems. We will go through a step-by-step example, demonstrating how to perform loading, transformation, filtering, graph creation and analysis, with a single Flink program.

Perl 6 and its implementation Rakudo are rapidly becoming ready for serious use. What's missing now is the huge module ecosystem that makes Perl 5 the swiss army chain saw it is.

Inline::Perl5 attempts to solve this by allowing you to use Perl 5 modules (including XS modules) in Perl 6. If that's not enough, Inline::Python may jump in and safe the day.

Java 9 will introduce a standard module system to the platform in order to modularize the platform itself, improve performance and security, and simplify the development and maintenance of large applications. In this session we'll discuss how these changes will impact developers in general and those who work on the JDK in particular.

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

Apache Mesos is a resource manager for datacenter infrastructure that uses a two-level scheduling model to provide hardware resources to various application frameworks. Organized in two parts, this talk will provide an overview of the Mesos compute model (comparing and contrasting how it relates to IaaS), and then walk through writing an application for Mesos using the framework API.

Apache Mesos is a resource manager for datacenter infrastructure that uses a two-level scheduling model [1] to provide hardware resources to various application frameworks. Similar to Infrastructure as a Service (IaaS), Mesos manages hardware and the execution of applications, while delegating the responsibility of deployment to other platforms. In the Mesos model, application frameworks are responsible for scheduling and deployment logic. Multiple frameworks can be run on bare-metal at the same time using a single pool of resources, including use-cases for long-running services (including Marathon, Aurora, Singularity), and batch/streaming (Hadoop, Storm, Jenkins).

The abstraction Mesos provides for running and writing distributed applications has proven interesting to several IaaS projects, including OpenStack [3] and CloudStack. [4] While IaaS typically addresses a larger set of concerns (including virtual machines, servers, storage, load balancers, and network), the narrow focus of Mesos on resource management has provided opportunities for integration between traditional IaaS and Mesos in the future.

Organized in two parts, this talk will provide both an overview of the Mesos compute model (comparing and contrasting how it relates to IaaS), and walk through writing an application for Mesos using the framework API.

Part one will cover their essential architectures and how they enable fault-tolerance with replicated master nodes, scalability to 10,000's of machines, and resource isolation between tasks. Part two will demonstrate how users can write custom application schedulers for Mesos by leading through an example (likely in Python or Go). Attendees will come away with an understanding of how the software abstractions Mesos provides (resource manager and scheduler) work together, and with essential knowledge to write a custom scheduler.

Citations: [1] http://people.csail.mit.edu/matei/papers/2011/nsdi_mesos.pdf [2] http://mesos.apache.org/documentation/latest/mesos-frameworks [3] https://issues.apache.org/jira/browse/MESOS-876 [4] https://twitter.com/ke4qqq/status/535421157202460674

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

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

The ODR-mmbTools is a collection of tools that can be used to generate a Digital Audio Broadcasting signal through Software-Defined Radio. These tools are used in a 24/7 production setup in Switzerland.

I have been working on improving them since my studies, and present here the current state of these tools and a small outlook on future work.

A Lightning Talk with a Munich student, about his first project in Libre Office: Optimizing the Libre Office Main Loop.

A PostgreSQL data recovery tale from a true story, where we dig deeper and deeper into the PostgreSQL internals in order to be able to get back some data from a destroyed cluster.

If that story doesn't leave you wanting to check all your backups before the talk has ended, I don't know what will.

Open vSwitch has traditionally focused on stateless L2-L4 packet processing. The introduction of stateful connection tracking, NAT, and L7 service integration extend the scope of Open vSwitch usage. In this talk, we will discuss the introduction of stateful services and cover the implementation of reflexive ACL and integration of L7 DPI on the data center edge.

The talk will be a thought-provoking exploration of operating systems and the software/hardware stack. It will be a high-flying tale of low-level gore, and is intended for everyone with an understanding of programming and/or software systems.

The focus of the talk is in core operating system architecture. While that is sometimes seen as a highly technical topic, the talk will put the subject into common terms to disband the illusion of magic, and to give the audience an idea of what the purpose of the OS is in 2015 and why they should care beyond just having one installed.

Some of the subjects that the talk will graze upon include:

• the need for an operating system (or lack thereof)
• historical perspective and what has actually changed since time immemorial
• hardware/software interface
• userspace is the new kernelspace (or is it?)
• why actually good ideas fail

Every discussed subject will not be backed by experimental evidence, nor does the presenter claim that all insights are original. The intent is to raise awareness of good ideas so that they can be implemented more widely, and to raise awareness of bad ideas so that they can be unimplemented more widely.

Lea is a Python open-source module dedicated to discrete probability distributions. It allows modelling uncertain information and derive probabilities in an intuitive way. It provides means to build random variables with given probability distributions, probability calculus with integers, standard indicators, conditional probabilities and generation of random samples. The forthcoming Lea 2 (should be ready for FOSDEM 2015!) shall include Bayesian reasoning, Markov chains and a high-level PPL (Probability Programming Language).

Lea is a Python package aiming at working with discrete probability distributions in an intuitive way. It allows modelling a broad range of random phenomenons, like dice throwing, coin tossing, cards hands, gambling, lottery, … with fair or unfair characteristics! More generally, Lea may be used for any finite set of discrete values having known probability: numbers, boolean variables, date/times, symbols, ...

Each probability distribution is modelled as a plain object, which can be named, displayed, queried or processed to produce new distribution objects. Lea provides standard indicators, conditional probabilities and generation of random samples. The forthcoming Lea 2 (should be ready for FOSDEM 2015!) shall include Bayesian reasoning, Markov chains and "Leash", a high-level PPL (Probability Programming Language).

On an implementation point of view, probabilities are stored using integers (e.g. not float), allowing to avoid any risk of rounding errors. Lea implementation heavily relies on Python's operator overloading, generators and duck-typing.

Not all free operating systems are feature-full POSIX systems. FreeRTOS is a minimal operating system which is designed to run on microcontrollers, and provide real-time scheduling. It is used in industrial automation and automotive.

A brief introduction to FreeRTOS, depending on audience preference, will be followed by either a hands-on workshop using PCs, or a demonstration on a board. The workshop includes how to get started, what can be done with it, and what type of features and pitfalls to expect from FreeRTOS.

Nix is a package manager that provides side-by-side installation of multiple versions of a package, multi-user package management and easy setup of build environments. This talk highlights how simple features of a package manager can change the way components are developed and deployed. We will investigate how Nix works and demonstrate how to use it throughout the development cycle. We will create a development environment, configure a system service, deploy to a container for testing and finally deploy a remote system.

• Package management:
• Issues: Correctness, Completeness, Interference.

• Deployment: Source vs. Binary.

• Nix

• Isolation: Hashing build inputs.
• Making build environment.
• Demo: Building a package.

• Source & Binary deployment.

• NixOS

• Configuration implies Installation.
• Configuration management & Abstraction.

• Demo: Generate configuration files around a service.

• NixOps

• Provisioning a configuration.
• Demo: Testing deployment.

It’s time for GitHub to focus on helping oss thrive. Our "Open Source by Design" project includes three steps. The first step is set to wisely alter the “no license” default, and is based on data we’ve purposefully accumulated. The second step aims to create governance templates that prevent problems that hamper projects. The third step is a new service to help projects comply with license requirements of third party code. The final part of the plan is the project's evaluation metrics.

GitHub recognizes that it has a role in the development of open source code. For starters, and as a platform, GitHub obviously hosts a great deal of it. As a product, GitHub's primary and presumed workflow is like that of an open source project, with loose or disaggregated networks of project maintainers, contributors, and users. And even as a corporation, GitHub has at times attempted to organize itself according to open source models, experimenting with non-coercive, collaborative, and geographically disparate structures of corporate organization.

GitHub's internal legal counsel wishes to discuss what GitHub can do to help existing open source projects thrive, to support new projects and new contributors, and to promote the development of the open source community. More specifically, and given GitHub's unique vantage point, GitHub Legal is working on projects utilizing tools of governance and process to contribute to open source in new ways. We wish to present the details of an "Open Source by Design" project in four parts.

The first part relates to altering the default understanding as to what it means for a project to be hosted without an explicit license on GitHub. We show why we need to tread with care when we alter this default, which data we are collecting that is intended to help us choose the new default wisely, and where that data seems to lead.

Our second part aims to help introduce governance infrastructure to open source projects in order to solve problems that such projects may some day face. We place particular focus on problems that, in GitHub's experience, often hamper open source projects as they transition along some relevant axis, be it user makeup, maintainer makeup, rate of adoption, commercial developments, design disputes, ownership disputes or the like. We believe that by developing and offering some measure of template governance structures, much confusion and many challenges that bedevil open source projects may be avoided.

We are sensitive to the potential side-effects of such a project, such as the stifling of alternate project organization and governance models. Another interesting aspect of study would be to what extent, if any, such bottom-up models of project self-governance would influence, supplement, or even act take on the role of law as they themselves became subject to things like increased adoption and standardization. This question seems particularly relevant in areas where formal legislative intervention is light.

The third part of an "Open Source by Design" project would be a new compliance service that aims to help projects comply with license requirements of third party code that they use, to avoid license inconsistencies where they actually occur and flags preventing the neglect of licensing.

Finally, we've given much thought to the metrics by which we would gauge the success of the different steps of this project once implemented and that could help us plan the second stage of the project.

This talk will introduce the Ada programming language to people used to more classical, weak-typed languages.

We will focus on how Ada uses its strong typing basis to prevent the most common programming errors at the language level, allowing the compiler to check them before they cause problems.

What exactly does it take to maintain a Ruby implementation? What is the process of porting over features? Why can this often take a considerable amount of time? This talk aims to dive into these topics in general but also how it affects Rubinius.

This talk will focus on what it takes to maintain a Ruby implementation and the process behind it. While there will be a strong focus on how Rubinius handles this, most of the topics also apply to other implementations such as JRuby and Opal. We'll also look into writing tests for Ruby, how this has been handled historically and why it's so important to have good tests.

One of the examples I'll be showcasing is how String#scrub, a new method in Ruby 2, was implemented in co-operation with Charles Nutter from JRuby and why this took quite a large amount of time (nearly a month). Another example will be Kernel#caller_locations, a method recently added to Rubinius which highlighted a potential bug in the implementation of MRI itself 1.

Enitity Linking is a very helpfully technique to improve search on natural text. I will present a system that allows to first spot entity's and than find related entity's using modern search engines like solr and elasticsearch.

In my talk I want to show how to use clojure and raw text, to get a wikipedia reflection out of a given natural language text. A reflection is a set of related entities from the wikipedia. I will show how to spot entity's in a given text using the Lucene FST feature. With the spotted entities I will show how to retrieve additional informations, like related persons, and places by using elasticsearch and the wikipedia category graph. The system is entirely written in clojure, and works in form of a web application with backed and fronted. The system makes use of the core.async library and the reactive UI library Om.

C++ has evolved quite a bit over the years, and the new C++11 standard finally has usable implementations on all relevant platforms. We aim to give an overview of the current status of C++11 adoption in the LibreOffice project.

Our approach for doing spelling correction has deviated considerably from the default approach Lucene is offering. While Lucene's FuzzyQuery uses a compiled Automaton to filter the dictionary rather efficiently, we directly use normal Automatons and intersect that automaton with a separate FST. This proves to be more efficient for our use case, since it saves memory and time to compile the automaton and also part of the time to identify the matching terms in the dictionary.

This approach gives us the possibility to store any meta-information with each term, which is used then to pick the top N spellcorrections. We build a term co-occurence graph, where each vertex is a possible spelling correction of a term and each link is the co-occurence in the same document. Each vertex and link get a score based on the meta-information and edit distance. Then we use graph reduction techniques until the graph contains the desired number of spellcorrections.

Valgrind with its set of tools provides a lot of powerful/sophisticated functionalities. However, this power has a price in CPU and memory.

This talk will discuss various ways to balance CPU and/or memory versus more (or less) functionalities.

Among others, we will explore command line options that control tools such as memcheck or helgrind, in order to detect more (or less) classes of errors, or tune the amount of data recorded by these tools.

We will analyse the impact of such command line options on the CPU and memory.

We will also look at the various ways to investigate the behaviour of Valgrind regarding memory or cpu behaviour.

Demo and small test cases will be used to illustrate the discussed functionalities.

In this presentation, Kristian Köhntopp and Martin Loschwitz from SysEleven in Berlin will explain how SysEleven uses OpenContrail to create decent SDN networking for the company's OpenStack platform.

A lot has been said about Software Defined Networking in the Cloud Computing context. Most modern solutions are based on technologies such as OpenFlow, Open vSwitch and Open Daylight. And they almost all have serious technical issues avoiding proper scale out and sometimes even impacting normal operations in small-scale environments. If you’re out for SDN today, you will find yourself soon looking out for alternatives. OpenContrail is one of them: Based on standard protocols such as MPLS, OpenContrail allows you to realize virtual networks while retaining the advantages provided by real hardware.

At SysEleven, we’ve been working on an OpenStack-based cloud offering over the last year. One of the major design decisions was to go with OpenContrail as the stack for Software Defined Networking. This presentation will give you an insight into why we found other solutions such as OpenFlow inappropriate and what the challenges were in getting OpenContrail up and running. You will learn what our current SDN scenario looks like and what conclusions we have come to based on the experience that we’ve made.

The advent of Infrastructure as Code (IaC) has radically changed how IT infrastructure is built and maintained. Instead of building and maintaining servers by hand, tools like Puppet can be used to describe and automatically configure entire data centers.

The implication of this is that the workflow of IT operations is starting to resemble the workflow of a traditional software developer. Writing code to make infrastructure changes instead of directly making changes opens up new opportunities for how changes can be made. The software development field has had 30+ years to learn how to effectively develop code, and their hard won wisdom can be ripped off wholesale to make it a breeze to develop IaC.

This talk will discuss the following:

• Using version control tools to more effectively administer infrastructure
• Writing and using tests to confidently make changes and get feedback earlier
• Using continuous integration services to test changes and run deployments

More and more people work with graphs nowadays, but it is not always easy to publish and share the graph interpretation on the web. Manylines is a web tool built at Sciences Po médialab to solve this issue. Some researchers and students use network visualizations to explore their data, but networks are not as clear as maps and sharing one’s interpretation is difficult. Manylines main innovation is to allow the user to explain and share a narrative about his network: an interactive story where each “slide” is a particular zoom, pan and filtering of the network, completed by a title and description, with fluid transitions like in Prezi.

Published as an open source prototype with the source code available on GitHub, Manylines is currently built around three screens: - The first screen allows applying the ForceAtlas2 layout to the network, in order to settle the “basemap”: the definitive positions of nodes and edges used to support further interpretations. - The second screen allows zooming and filtering the network to explore the data and “take snapshots” representing different insights. - The third screen allows composing narratives by building a series of snapshots, adding a title and short description for each step. The result is an interactive slideshow widget where the user's exploration of the network is guided step by step, revealing the key interpretation points one by one.

Manylines is a single webpage app built for HTML5 browsers. It makes an extensive use of the sigma.js library to deal with networks within the browser and it implements different features inspired from Gephi, the reference desktop graph viz platform. The WebGL visualization (with Canvas fallback) implemented by Sigma.js allows great performance for networks up to 1000 nodes on an average computer. To reach this level of performance, we optimized the javascript version of the ForceAtlas2 algorithm used by sigma.js. We ported it to use web workers and we optimized the Barnes-Hut quadtree approximation in this context by implementing it as an iterative and not recursive process. We made an extensive use of sigma.js' custom renderers and cameras to build dynamic graph thumbnails, snapshots and widgets. The server side stores the networks, snapshots and narrative data in a Couchbase database (which we discovered in FOSDEM 2014) accessed by a Node.js express REST API.

As ADAS and infotainment require more electronics, using an hypervisor is a solution to gather multiple boards into one. Xvisor is an open source lightweight hypervisor for embedded systems that perfectly fits the needs of the automative industry. It is a complete monolithic type-1 hypervisor with full virtualization and paravirtualisation support, showing better performances than KVM.

We, OpenWide and the Institute for Technological Research SystemX, are working on its port on i.MX6 boards.

Nowadays, as the Advance Driver Assistance Systems (ADAS) needs drastically increases, the number of electronic boards, cables, communication channels, and devices explodes. In the meantime, infotainment is one of the selling points for automotive industries to sell new cars, which also mean more electronics. Thanks to the Genivi initiative, those systems will run under Linux, whilst car control electronics run under Autosar (AUTomotive Open System ARchitecture) OSes, which are closed source binaries.

Gathering multiple boards into one with hypervisors is a solution to reduce costs and increase functionalities. Xvisor is an open source lightweight hypervisor for embedded systems that fits perfectly the needs of the automative industry.

It is a complete monolithic type-1 hypervisor with full virtualization, allowing unmodified guest support (useful for AUTOSAR components) and paravirtualization, which can help improve Linux guest performance. Moreover, on ARM, Xvisor shows better performances than KVM. It has been mainly developed by Anup Patel, and joined by Jean-Christophe Dubois, Himanshu Chauhan, Sukanto Ghosh and Pranav Sawargaonkar. This presentation will focus on ARM usage while introducing the concepts of virtualisation, paravirtualisation.

Even if Xvisor is a young project, publicly visible from June 2011, as its sources are very close to Linux, ports remain quite fast and easy. It uses device tree files, both for board definition and configuration parts. It is in this way that we, OpenWide and the Institute for Technological Research SystemX, continue the work of Jean-Christophe on the i.MX6 port of Xvisor, for the Boundary Devices Nitrogen6x (and the Freescale SabreLite).

Then will show: - the binary rewriting tool usage on guest binaries, - Xvisor running on Qemu, - configurable and dynamic guest creation - and Xvisor running on the i.MX6.

Java is a great language for rapid prototyping. For those interested in multimedia and UI design in Linux, however, there are limited options that provide a varying degree of performance and feasibility. It is quite straightforward to perform I/O on a Video 4 Linux device or the Linux framebuffer in C, but not as straightforward in Java. The end result of this project enables Java programmers program devices like the Linux framebuffer much ease as they use byte[] and int[] classes. An interactive demonstration will be made available as part of the workshop. Moreover, the implementation demonstrates speedups of up to 150x in MappedByteBuffer I/O.

This patchset [1], currently implemented as a proof of concept using JamVM and GNU Classpath, enables

1) the JVM to mmap special files (i.e. those in /dev) - something no other VM can do AFAIK 2) a true, direct, MappedByteBuffer from any mapping or pointer in the CRT 3) provides a safe, memory-managed Java backing array, via MappedByteBuffer.array() 4) speeds up MappedByteBuffer I/O by factor of up to 150 times!!

In human terms, it lets me draw to the FB[4] using pure Java :-) Since originally posting my patchset, I have made a few changes including removing the custom JNI calls in favour of using sun.misc.Unsafe API.

• If possible describe why Free Java is helpful or perhaps even essential to your project.

This would have been practically impossible to do with a closed-source JVM and class library. JamVM and GNU Classpath have been open source for as long as I've known, and that's enabled me to become familiar enough with the source to make it do whatever I needed in various embedded environments.

• What the audience will learn from the talk.

I will provide a fairly minimal VMWare image so that the audience can easily download the VM, modify some Java code, and draw whatever demo's they would like to to the FB - using pure Java! My forks are up on github [2,3]

• How can people help out with the project, what feedback are you looking for?

I would like to have some feedback about the patchset to get it in good enough shape for acceptance to GNU Classpath and JamVM. I would like to entice some other tinkerers to port the changes to OpenJDK as well, and would like to get some feedback about possibly using JNA in combination with my /dev/fb and /dev/event classes. Lastly, I would very much like to open up the discussion about forming a performance-optimization group.

Recording me on audio and/or video: YES (acceptable)

[1] https://plus.google.com/+ChristopherFriedt/posts/N4eVKvn2oL4 [2] https://github.com/cfriedt/jamvm [3] https://github.com/cfriedt/classpath [4] https://plus.google.com/+ChristopherFriedt/posts/XkNYEfgESea

Scrapy is a fast high-level screen scraping and web crawling framework, used to crawl websites and extract structured data from their pages. It can be used for a wide range of purposes, from data mining to monitoring and automated testing. In this talk some advanced techniques will be shown based on how Scrapy is used at Scrapinghub.

Open Source software can play a critical role for the roll-out of broadcast standards. This is also true for new caption and subtitle standards. The focus on the presentation will be on the OS Subtitle Conversion Framework (SCF). SCF consists of different software modules that aim at a faster and conformant adoption of the EBU-TT standard, an XML based subtitle standard defined by the EBU. Apart from SCF also other OS software that are important for the implementation of subtitles standards will be discussed (e.g. mp4box from GPAC or the WebVTT parser from Anne van Kesteren).

In the process of designing, implementing, and using Perl 6 (or any programming language), people often refer to ""the language specification"" as a commonly understood and perhaps self-evident fixed reference point. For mature languages this can be reasonable, because the people using that language have generally developed a shared understanding of what constitutes the language's specification. But languages are not all specified in the same manner, and in a new or rapidly evolving language it may be unwise to prematurely commit to an inflexible specification. Perl 6 has gone through several imprecise notions of what constitutes its specification, such as design documents like the Synopses, reference implementations of certain features, and the ""official"" test suite. This imprecision sometimes leads to misunderstandings among developers, confusion for newcomers to the language, and difficulty communicating with external audiences. This talk presents a historical perspective on how Perl 6's specification process has evolved over the past decade: identifying things we've done (or are doing) wrong, things we've gotten very right, and ideas of what that process ought to look like going forward.

This talk will present the work to integrate an OpenGL vcl backend.

GlusterFS is a distributed scale-out filesystem that runs on commodity hardware. In this session, Niels de Vos will provide an architectural overview of GlusterFS and discuss how its file, object & block interfaces can be used to build a scale-out storage solution for IaaS needs. Details on new features , use cases and interesting challenges with GlusterFS will be provided. As part of this session, Niels will also discuss integration of GlusterFS with other open source ecosystems like OpenStack, oVirt and provide future directions of the GlusterFS project.

This talk is an overview of the current compatibility of the various app stores with the major copyleft licenses.

I will then speak about the technical limitations of what those platforms impose on application licenses. I will also cover license strategies to have cross-platform FLOSS applications distributed on those app stores.

This talk is an overview of the current compatibility of the various app stores (Apple App Store, Google Play Store, Windows Store, BB, etc...) with the major copyleft licenses.

I will then speak about the technical limitations of what those platforms impose on application licenses, notably on Android, where a large part of the userland is licensed under Apache 2.

I will also cover license strategies to have cross-platform FLOSS applications distributed on those app stores, if one would like to do it.

Most of the information gathered here are based on the work we did on VLC to get it running on numerous mobile platforms.

The EFL is a toolkit for writing cross-platform applications. Enlightenment is a desktop shell built using this toolkit. Both the EFL and Enlightenment are fast and light on resources (which made them the toolkit of choice in places such as the Tizen operating system and embedded environments) while remaining scalable, but their low level approach complicates portability. In this talk I'd like to summarize our past portability issues and tackle current ones, as well as talk about our future direction. The talk will be focused on FreeBSD, using it as an example, but will also cover our general issues and portability to other operating systems including Windows and OS X.

The EFL (Enlightenment Foundation Libraries) is a toolkit for writing applications (desktop and mobile alike), notably used by the Tizen operating system as well as other places. Enlightenment itself is a desktop shell built upon this toolkit. It's clean, lightweight and written entirely in C. However, its low-level implementation approach has, besides small size and high performance, a flaw, which is portability, an issue I have to deal with very often as part of my work at Samsung.

Enlightenment/EFL developers have always tried to write relatively portable code, but there are still quite a few issues (major and minor) that remain. As a FreeBSD user I think that portability is a very important topic that should not be overlooked, and that's why I would like to cover these issues in this talk as well as propose some solutions. The problems we're currently facing include dependency on certain very Linux specific things, such as udev, Wayland etc. as well as differences between APIs provided by those operating systems and differences in tooling (build systems...).

By coming up with solutions to these issues, we can make the EFL and E work better on non-Linux operating systems (including but not limited to the BSD family, Mac OS X or even Windows) as well as make it work better in those places where it already runs, making it more accessible to more developers.

In this talk I will introduce the EFL and Enlightenment, cover portability problems across different operating systems with a focus on *BSD (and lesser coverage of OS X and Windows) and present our future plans as far as platform coverage is concerned.

F*watch is an infinitely hackable GPS watch with many sensors based on a 100% Free design. Everything is Free, from the PCB and watch housing design to the software stack. Moreover, only Free software tools have been used during the development.

F*watch. Why should your watch be different?

The talk describes the development process and shows a first prototype, along with performance measurements and future plans.

The presenter will explain Automatic Multicast Tunneling, a draft RFC allowing to extend multicast content distribution to unicast-only connected receivers, and its implementation in the flexible multimedia framework Upipe. He will also show how it is possible to take advantage of AMT in web browser, using the Native Client plug-in of Upipe.

In 2005, Matt Mackall picked Python to implement a new version control system: Mercurial. Ten years later, the project is a success! Thanks to python? Lets see what shinning advantages met us and what issues we, developers, had to work around. We'll also take a detour to the place were python outcrop to the users, the extensions system.

In 2005, Matt Mackall picked Python to implement a new version control system: Mercurial. Ten years later, the project is a success! Thanks to python?

In this Talk, we'll go over on the advantages of Python that helped the project both in its early life when so much feature needs to be implemented, but also nowaday when major companies like Facebook bet on Mercurial for scaling. We'll also point at the drawback of choosing python and how some work-arounds had to be found. Finally, we'll look at how the choice of python have an impact on the user too with a demonstration of the extensions system.

The WAL record format was revamped in version 9.5. This presentation goes into the details of the WAL format, and the reasons for the change.

Midonet, our distributed SDN solution, has been finally released to the the community and we’d like to share our excitement with you. You’ll learn about the core concepts, why it’s different, its core design and why you would choose it for your project/business. Or not. You’ll be introduced to concepts like Topology Aware Edges and JIT Datapath flow computation as well as our distributed agent model. You’ll learn why we strongly believe in having intelligent edges and how this impact the overlay topology definition as well as the NFV implementation. We’ll share with you the challenges we’re facing, our ideas and our product vision. If you believe in the SDN future, please join us, bring your ideas and be part of the community we’re building. Fun included!

From blame logs to authors signing their names on their paintings; everyone appreciates and deserves credit for what they do. This has been codified in open licenses such as those from Creative Commons which put attribution as one of the requirements for re-use. Over the last two years, a number of libraries and tools have been developed to make attribution easier and seamless, and this talk demonstrates how they all fit together, how you can use them in your programs, and how a browser plugin can help you both find and attribute openly licensed works.

Commons Machinery is an initiative supported by the Shuttleworth Foundation to give some much needed attention to metadata support for creative works. First and foremost, the project has worked with images and metadata standards for images. The software developed include a catalog of openly licensed creative works, a browser plugin interacting with that catalog, and several libraries to support the managing of metadata for creative works. In total, this talk will skim across the following technologies and tools:

• The Catalog - a free software backend for metadata storage, currently in production and seeded with metadata information about all openly licensed works from Wikimedia Commons, as well as other collections. The catalog API supports querying for images by URL or by a perceptual hash that will help you find images even if they've been resized.
• Blockhash - a JavaScript, Python and C library and utility to calculate basic perceptual hashes of images, with particular emphasis on verbatim reuse scenarios. This means that images that have been rescaled (sometimes heavily) or changed format, should result in identical or near-identical hashes, whereas images that have been modified to create derivative works should result in more different hashes.
• Elog.io - a Firefox and Chromium plugin that can query the Catalog for information about images to determine if they're openly licensed or not, and show you which images on a web page are openly licensed, as well as give you source links and a way to automatically attribute those images when you re-use them.
• hmsearch - A C++ implementation (with Node and Python interface) of hamming distance algorithm HmSearch using Kyoto Cabinet, used in the Catalog to search for hashes which are nearly identical.
• libgetmetadata - a library to retrieve metadata about images based on their URL
• libcredit - formats appropriate credit statements from an RDF graph with metadata

Debugging performance problems can be a daunting task, especially when you are short on time and lack proper tools that integrate nicely with your custom application landscape. Thermostat was designed to answer the most interesting questions related to performance measurement and application monitoring. It takes advantage of performance metrics and serviceability features of OpenJDK to provide a holistic view of the system. In this session, attendees will get a chance to see Thermostat in action as it is used to analyse programs, gather data, and debug issues affecting performance and functionality.

In 2013, at the Embedded Linux Conference in Europe in Edinburgh, there was a race between a dog and a blimp. It was said that despite the dogs win, that the blimp had participated in the miracle of flight. In 2014 we intend to show that the brains of that dog can be transplanted and that it too, can participate in the miracle of flight. The talk is mainly targeting taking an off the shelf embedded platform, MinnowBoard Max, and it's use in UAVs, specifically quad-copters. With the ability to do real time computer vision, as well as various GPIO capabilities we'll explore the directions that significantly more autonomous UAVs can take with Linux and embedded platforms using, mostly, off the shelf components.

In 2013, at the Embedded Linux Conference in Europe in Edinburgh, there was a race between a dog and a blimp. It was said that despite the dogs win, that the blimp had participated in the miracle of flight. In 2014 we intend to show that the brains of that dog can be transplanted and that it too, can participate in the miracle of flight. The talk is mainly targeting taking an off the shelf embedded platform, MinnowBoard Max, and it's use in UAVs, specifically quad-copters. With the ability to do real time computer vision, as well as various GPIO capabilities we'll explore the directions that significantly more autonomous UAVs can take with Linux and embedded platforms using, mostly, off the shelf components.

There are a multitude of applications where this kind of technology is useful, from basic hobbyists, forestry services to search and rescue.

Munich student talks about his first project for libreoffice: Implementing a OpenGL canvas backend.

GTK+ is an open-source library that allows to quickly and easily build a graphical user interface, using standard widgets like buttons, combo boxes, text and tree views, scroll bars, etc. Even though GTK+ is written in C, it can be used from an Ada application thanks to GtkAda, an object-oriented Ada/C binding.

Illustrated by a poker game application, this presentation will explain the essential concepts of GtkAda. It will show how to create the most common widgets and how to interact with the user.

Enlightenment Foundation Library is a set of libraries designed to use the full potential of any hardware to do great UI. It has been designed with the embedded devices in mind, but it is a desktop class toolkit. Being done in C, it is providing a stable API/ABI, high efficiency, low memory and low battery usage for all kind of Linux device. Enabling development of modern UI adapted to any hardware that run Linux. These are the reason why Samsung use it in its Tizen devices. This talk after a short overview of what this libraries cover, will focus on last year improvement and where it is heading. It will also be an opportunity to learn about project around EFL that will help people develop product with it. And it would also be a good opportunity to see where EFL are used with some real use case.

How is it to be a fairly large project upstream of several Linux distributions? How is it do be downstream of such a project? Among the challenges are coordinating between distributions, handling different expectations from distributions and users, and technical issues such as making the software easy to package. Using MySQL as the example, we'll go through several real-life cases and try to see them from both sides of the developer-maintainer relationship.

MySQL is the world's most popular open source DBMS, with a large user base on Linux, Windows, OS X, FreeBSD, Solaris, and others. Besides direct download from the upstream web site and package repositories, Linux distributions are the major delivery channels for MySQL. This talk is based on real-life experiences in the upstream-downstream relationship between MySQL and the major Linux distributions over the last few years.

Among the topics covered are upstream's role in coordinating between the different distributions, how to handle distributions that deliver on platforms that are unsupported by upstream, handling bugfixes and requests for new features in stable releases, and how having an upstream package repository can improve the quality of packages in the distributions.

The target audience is software developers that have or want to have their software packaged for one or more Linux distribution, package maintainers in distributions, and end users wanting to understand more about how Linux distributions are made.

The fact that Ruby has different implementations is strange but also powerful as it allows us to write extensions. Although writing an extension can be a daunting task, there's no better way to get to the heart of what exactly Ruby objects are and the reason for some of the language's quirks.

In this talk, we'll use an example of writing a C extension for Ruby to use a third-party C security library. We'll peel back the layers of Ruby objects to deepen our knowledge of MRI and to understand in a little more detail what it really means to write object-oriented code.

Ruby is a very high-level language and I've found that Rubyists often lack more lower-level knowledge concerning operating systems, memory management, differences with other languages, and typing. Writing a C or Java extension exposes some of these concepts to the Rubyist and highlights the uniqueness of the language. I would like to share some of what I've learned from writing C and Java extensions with the RubyConf audience.

In this presentation I'll use an example of writing a C extension so that Ruby code can make use of a third-party C security library. The topics I'll touch on are:

How to write a rake task so that your extension compiles when your gem installs How Ruby objects are represented in C code The appropriate C functions to use when going back and forth between Ruby objects and C code

Here is the c code: https://github.com/mongodb/mongo-ruby-driver/blob/1.x-stable/ext/csasl/csasl.c

Why I'm qualified as a speaker on this topic:

I had to write both a Java and C extension for the MongoDB Ruby driver using a sasl library for GSSAPI authentication against MongoDB. There was minimal documentation available for how to write extensions in Java or C and I learned a ton from having to figure it out on my own. Having written the extensions gives me a much deeper understanding of MRI in particular and general knowledge about programming languages.

I've given numerous talks at conferences, including RubyConf '13, invited to BaRuCo '14, RailsConf '13, RailsIsrael, RuLu, GoGaRuCo '13, GoRuCo '13, ScottishRuby, etc. I love giving talks and put a lot of heart and soul into the preparation. I've heard people usually think they're high quality = )

How can you store 86 billion measurement points in 30 gigabytes and search through it within a few milliseconds on your laptop? A relational database? No! Apache Solr empowers you to do this if you follow a few concepts. The horizontal scalability capabilities of Solr bores away the borders of your laptop and allows you easily to scale out to your needs. In this code intense session we give an introduction how to store time series data in Apache Solr.

How can you store 86 billion measurement points in 30 gigabytes and search through it within a few milliseconds on your laptop? A relational database? No! Apache Solr empowers you to do this if you follow a few concepts. The horizontal scalability capabilities of Solr bores away the borders of your laptop and allows you easily to scale out to your needs.

In this session we give an introduction how to store time series data in Apache Solr. QAware has developed an Enterprise Application Performance Analysis Platform on top of Solr. Based on code examples you will see how easy multi-dimensional time series data can be stored and retrieved. We show how Solr features like Facets, Filters and Queries can be used to build graphical user interfaces with an outstanding performance and usability. We also compare this approach to other time series databases like InfluxDB and relational databases like MySQL.

The SPDX specification is a standard format for communicating the components, licenses, and copyrights associated with a software package. Despite that relatively simple explanation, myths and misunderstandings seem to abound as to what SPDX does and does not do; whom benefits from SPDX and how; and more. This talk will address some of the commonly heard myths and misunderstandings.

This talk will also describe the key changes accompanying the upcoming official release of SPDX 2.0.

LibreOffice recently has finished to use a consistent build system, this made it easy to now allow it to be debugged, modified and improved in an IDE for developers.

This lecture will show how we improved LibreOffice to be debugged, edited and hacked upon in an IDE with nice features like code-completion. It will show some examples on how easy this makes contributing to LibreOffice and how the support of such tools can make you an contributor too.

This session will cover in detail the ongoing effort of integrating the oVirt virtualization and Gluster storage resources in single commodity boxes that can scale horizontally. The presentation will include the description of the technical challenges encountered, the status of the ongoing effort and the roadmap for the possible future improvements.

• oVirt virtualization and Gluster storage overview
• Architecture, hardware and software setups
• Scaling horizontally
• Challenges of the oVirt and Gluster Hyperconvergence
• Current status and other possible improvements
• Roadmap and future additions

Pure Perl is awesome. But often there are situartions where Pure Perl™ means that your program will either be slow, or it will not comply with industry standards. On the other hand, using battle tested open source libraries is a sane choice, but implementing the bindings to a language like Perl can be quite challenging. This talk is a walk-through this business, illustrating the bindings to the library libxml.

This talk is about how different opensource tools are use by Trace TV team

Ptpython is a better Python REPL built on top of prompt-toolkit. In this talk we'll have a look at what pt(i)python is and how to use it. Further we'll have a look at the underlying library prompt-toolkit. We'll see how it works and how easy it is to create a custom REPL with syntax highlighting, code completion and input validation. (for instance to create an SQLite client.)

Prompt-toolkit is a library for designing command line interfaces. Basically, it can be a pure Python replacement for GNU readline: it implements most of the Emacs and Vi keybindings as well as reverse search and code completion and it supports double width characters. However, it can be even much more powerful. There is syntax highlighting of the input, multiline editing, support for toolbars, custom layouts, multiple input fields and integration with other event loops (e.g. asyncio).

In this talk we will see how easy it is to create a custom command line interface: it doesn't take more than a few lines of code. Further we'll see how to add input validation, code completion and other extensions, each without much effort.

We will also have a look at ptpython. This is a Python REPL build on top of this library. We have a look at several interesting features of ptpython which can make your REPL experience even better. And finally, there is ptipython, the front-end for IPython.

Implementing a tool to automate IT infrastructure management has many undeniable benefits. But that doesn't mean there aren't some drawbacks too (usually outweighed by the benefits) that we should be considering, and working to reduce or remove.

Implementing a tool like this in a team usually has a pretty significant impact: new processes, new language(s) to learn, new way of doing pretty much everything on your infrastructure. These tools are complex, so a minority of the team tends to become experts in it, and tries to lead the others. Resistance to change is common and understandable, but unfortunately, this can end up with some of the team members being left behind by the sudden and massive changes to their work. This is clearly not a Good Thing, and certainly not showing very good inclusiveness towards everyone. It is also making some configuration management projects fail, which is definitely a Bad Thing for those of us trying to implement them.

How to improve this situation is a topic dear to me. This has always been the focus of the Rudder and ncf open source projects I work on - making our technologies more accessible, easier to adopt and simpler to understand. Some key points we have focused on include: - Avoiding the necessity to write code (user interfaces of course, but that can be combined with other users writing code) - Separating roles so that experts can implement the how and others can focus on the what - Minimising the amount of effort required (sane and non-surprising default values, auto-configuration where possible, ...)

This talk will explain some of these concepts, and show how we have achieved considerable success using the ""ncf builder"" web interface that can be used to write configuration management policy without writing any code (see http://www.ncf.io).

Java is a platform of choice for many IoT applications, from building smart gateways that bridge sensors to the cloud, to device management infrastructures or home automation systems. This session provides you with concrete examples of how to build end-to-end solutions with the Eclipse IoT Java stack and in particular how to use open-source projects such as Paho, Kura, Californium and Concierge on top of OpenJDK. You should join this session if you have Java developments skills that you'd like to put to good use for your next IoT project, and if you are interested in learning more about how to use open standards like CoAP, MQTT, 6LoWPAN, … in your Java applications.

Due to scalability issues that the current Internet is facing, the research community has re-discovered the Locator/ID Split paradigm. Among the various proposals, the most successful is LISP (Locator/ID Separation Protocol), which is currently discussed at the IETF and strongly pushed by Cisco.The talk  overviews OpenLISP (www.openlisp.org), an open source implementation of LISP. The talk is organized in two parts. A first part will overview the main principles of LISP and the way it works. The second part, which is also the main part of the presentation, will describe the kernel implementation work done.

In the last years both academia and industry have worked toward new Internet architecture proposals, due to the awareness that the current architecture is facing unforeseen scalability issues, concerning the restless increase of the BGP routing tables, addressing, mobility, multihoming, and inter-domain traffic engineering. The general consensus is that splitting the locator and identifier roles of IP addresses solves these issues and is necessary for the Future Internet architecture. However, in practice, several constraints have to be taken into account in order to design a viable solution that can be incrementally deployed, without disrupting the existing communication infrastructure, whilst providing benefits, hence incentives, for early adopters. An instance of such a paradigm is the Locator/ID Separation Protocol (LISP). LISP was first proposed by Cisco in the IRTF (Internet Research Task Force) and is now under development in the IETF (Internet Engineering Task Force). Aiming at being incrementally deployable, LISP has evolved from its initial design in order to accommodate the constraints that the current Internet imposes, but still offering an effective solution for the scalability issues. Our goal is not to convince the reader about the merits of LISP, or the general Locator/ID Split paradigm, and neither to provide numerical results of its performance. Rather, the talk aims providing an overview on how LISP works and what are the basic principles, including its implementation aspects.

Time dimension is fundamental in many different contexts, from statistical analysis to representation of cause-effect relationships, from forecasting to automatic control systems.

Representing this kind of data in "traditional" databases can lead to performance problems, due to their quantity, frequency and domain model; this is why NoSQL solutions are widely used in this field.

In this talk we will show how to use OrientDB, a Document-Graph Database, to store, process and query this type of information in an efficient and effective way.

Time dimension is fundamental in many different contexts, from statistical analysis to representation of cause-effect relationships, from forecasting to automatic control systems.

Representing this kind of data in "traditional" databases can lead to performance problems, due to their quantity, frequency and domain model; this is why NoSQL solutions are widely used in this field.

In this talk we will show how to use OrientDB, a Document-Graph Database, to store, process and query this type of information in an efficient and effective way.

Description: I have extended Cachegrind to include L2 Cache Inclusion & TLB Measuring. The main goal of this talk is to present and explain how these two extensions work; why they might be useful, what one can do with them, how did I test them, etc. (see full description for the points to be covered)

Intended Audience: Valgrind core developers and Cachegrind users

• Overview of Cachegrind and its limitations
  • Functionality added by my extensions

And then, for both TLB measuring and L2 cache inclusion the following points will be covered:

• Usage
• Example use
• Available options
• How does the extension interact with the original code
• How to extend it
• Validity of results
• Introduced slowdown

During the Google Summer of Code in 2012, Gökçen Eraslan implemented digital signatures for LibreOffice's PDF export. There were some glitches left in the feature, for instance it did not really work well on Windows, which is where most of our users are. Because of that, the functionality was marked as "experimental" and was thus not easily available to users. Recently, thanks to a crowdfunding effort, we had the opportunity to improve this feature. The presentation will describe that work and show how to use the feature.

Recent revelations about the scope of government surveillance have touched off renewed interest in encryption and personal data privacy, and prompted technology companies to offer more protections for users' data. In response, the U.S. government has made moves toward increased regulation of encryption software. This talk will discuss the laws regulating surveillance and cryptography, how those laws apply to free software, and opportunities for community response to the new crypto wars.

Welcome and Introduction to the FOSDEM 2015 Lightning Talks.

The lowRISC project was established in the summer of 2014 with the aim of producing a complete open-source System-on-Chip in volume, with low-cost development boards. Alex Bradbury, one of the co-founders of the project will discuss the progress to date and the path to the first test chip. lowRISC implements the open RISC-V instruction set architecture and is exploring ideas on improving security via tagged memory and increasing flexibility through the addition of RISC-V 'Minion' cores to implement soft peripherals. This talk will discuss the potential benefits of a fully open-source hardware ecosystem, the challenges of getting to first silicon, and how the open source community at large can help.

There has been an explosion in interest in low-cost hardware platforms in recent years with many (e.g. Arduino and BeagleBone Black) having their schematics and PCB layout released under an open hardware license. These platforms are supported by open-source toolchains, applications, and libraries yet the processor this software targets remains closed. We believe there is an opportunity for open source processor and SoC designs to influence industry in a way similar to the successes we've seen in open source software - to help increase the pace of change of development, more easily move ideas from research to real world usage, and to lower the barrier of entry to the market.

Two features we are focusing on for our first test chip are tagged memory and 'minion' cores. Tagged memory has applications in security, to prevent control-flow hijacking attacks or for debug or performance monitoring. The 'minions' we propose are small cores which also implement the RISC-V instruction set, used for implementation of I/O protocols in software, secure isolated execution, or many other potential uses. This talk will describe the current status of the project, our planned path to production silicon, and how the wider open source community can get involved.

Our world is full of small powerful devices; but most of them run Android.

I'll show how Mer, SailfishOS and HADK lets us reuse them as full blown linux systems - with touchscreens, 3D graphics, modem, wifi, usb...

At the heart is libhybris - talked about at FOSDEM; found inside the Ubuntu Touch distro, invented and developed at Mer & Jolla where it's used in the Jolla phone (ARM) and soon the Jolla tablet (x86).

Together we can route around the breakage of closed binary blobs and work on FOSS on these devices.

FOSDEM Companion is a mobile schedule app for Android, first released for FOSDEM 2014. Its code is open source and designed as a reference implementation for this kind of application. This session will cover the architecture of the app and its building blocks, the motivation behind its features, what's new in the 2015 version and the best practices for designing a modern Android application.

The concurrent-ruby is a gem which provides a variety of concurrency abstractions at high and low levels. It is an unopinionated toolbox allowing users to pick the right tool for a given concurrent problem. The gem has Agents, Actors, STM and many more.

The talk will cover: - Overview of the available tools. - Examples of some abstractions. - Java and C specific implementations.

Caciocavallo has been one of the very first external projects to land in the OpenJDK repository and sponsored by the OpenJDK Porters Group. Named after a delicious cheese we're never tired of eating, it had the original purpose of refactoring the AWT peers to allow different implementations to be added to OpenJDK. The project evolved very quickly until it became itself a full implementation of AWT based on Swing with just enough abstraction to allow custom plugging into the Java2D system for rendering. As time passed, this characteristic was used to implement a GUI testing framework running on offscreen buffers to avoid the usual problems of focus stealing and random mouse moving that plague every other GUI testing framework (here everything is emulated!), and finally a full Web based backend to allow application to run remotely but still be visible on the local screen. This talk will cover the progress we have done over the years, we will show how easy is to implement a new backend and how this project could be used to give Wayland support to OpenJDK. We will show the testing framework and finally we will discuss about WebJDK, an idea to give more web oriented functionality to OpenJDK and use the web backend to enable fully cloud based applications.

Daala is a next-generation royalty free video codec under development by Xiph.org and Mozilla.

Mozilla Firefox is a Web Browser. The red panda just turned 10. For the last 4 years, we have been releasing a major release every 6 weeks. During this talk, we will explain how we have been able to reach this goal.

Releasing software is hard. Doing it every 6 weeks is harder, especially in an environment like a Web browser in which there are constant evolutions and changes. We will explain how we have been able to reach a high quality level on a software complex as an operating system while keeping frozen deadlines. We will present our workflow, our tools and our organization to reach these goals.

Traditional Linux distributions are updated via one of two methods: utilizing package managers like RPM, apt, or pacman or good old "config, make, make install." We will analyze how atomic CoreOS updates are developed, packaged, and distributed in order to sign an image and distribute it to the masses.

Decentralize the web! Everyone wants to, but actually getting a decentralized network of websites is notoriously hard. Luckily, much of the hard work is already done. Learn about federation standards (including recent activities at the W3C Social Working Group) and how to use PyPump, a library to make federating with Python easier, and how we're tackling site-to-site federation in GNU MediaGoblin.

Decentralize the web! Everyone wants to, but actually getting a decentralized network of websites is notoriously hard.

Luckily, much of the hard work is already done. Learn about federation standards and how to use PyPump, a python library to make federating with Python easier following the Pump API, and how we're tackling site-to-site federation in GNU MediaGoblin.

In addition to examples on how to federate, learn what the current state of standardizing federation protocols are, lessons learned through the standards process, and the latest to come out of the W3C Social Working Group.

PHCpack originated from bundling programs to solve polynomial systems with symbolic-numeric and polyhedral methods. The core of PHCpack consists mainly of Ada code, with interfaces to C and Python. Its blackbox solver is accessible from various scientific software packages such as Macaulay2, Maple, MATLAB, Octave, and Sage.

The goal of the talk is to explain the application of software engineering principles and the role of Ada in the development of PHCpack.

The Ceph storage system is used by many IaaS software. It provides self-healing distributed storage in many forms (block device, file system and object store).

An overview of the most recent Ceph features will be followed by use cases about how current IaaS stacks could leverage them.

PostgreSQL 9.4 introduces a new type, JSONB, index types, operators... all kinds of new infrastructure for processing JSON. It's all rather overwhelming.

We'll look at the current set of tools, including real-life applications and performance metrics, and talk about options as to when it is a great and perhaps still not-as-great idea to use JSON.

The clever minimalism and flexibility of the X-Windows system has allowed it to be ported to a diverse range of platforms. Recently, that flexibility has allowed the X.org server, client libraries, several window managers, and a range of applications to be ported to run stand-alone inside the Chrome web browser using a technology called Native Client. This talk explores the unique challenges of porting X11 to Native Client and the browser.

Native Client (NaCl), is an open-source technology that allows native machine code to run securely sandboxed in the browser. Two layers of sandboxing, a static verification inner sandbox combined with Chrome’s outer process sandbox, ensure users can safely run untrusted applications. Modified GCC and LLVM based toolchains allow applications to target NaCl. An I/O API called PPAPI, mirroring the security constraints of Javascript, is provided to NaCl applications.

This talk will discuss the central porting challenges including: emulation of POSIX APIs—processes, sockets, files—on top of Web-centric APIs, packaging, and protocol transport. I’ll demonstrate several X11 applications running the browser, including Emacs, Tcl/Tk, and Xeyes! We’ll look at how X11 applications can interoperate with our in-browser development environment and discuss how you can use this technology to bring your X11 application to the Web.

Check out our ports collection at: https://code.google.com/p/naclports/wiki/PortList

Learn more about Native Client: https://developer.chrome.com/native-client/overview

Pflua is a fresh implementation of the well-known pcap-filter language (pflang), designed to filter network traffic in the Snabb Switch. It is, to our knowledge, the fastest pflang implementation. This talk introduces pflua, its two compilation pipelines, its performance, and shows a demonstration of pflua filtering traffic at 10Gb line-speed in a Snabb Switch.

Packet filtering generally works by taking pflang expressions and compiling them to bytecode for the BPF virtual machine. Pflua, a new pflang implementation, instead compiles pflang expressions to Lua code, which are then optimized at run-time to native machine code by a trace compiler (LuaJIT). Tracing seems a particularly appropriate strategy for the packet filtering use case, as you end up with linear machine code that reflects the shape of actual network traffic.

Pflua is a project that lives at the intersection of networking and compilers. Its pflang to Lua compiler builds an AST that is exhaustively optimized, folding constants and tests, inferring ranges of expressions and packet offset values, hoisting assertions that post-dominate success continuations, etc. For compatibility, pflua also has a BPF bytecode to Lua compiler, whch leaves the first layer of compilation to libpcap, while benefitting from pflua's much better run-time performance.

Join us in this Pflua presentation and learn about:

• The architecture of Pflua.
• Compiler optimization techniques implemented in Pflua.
• Benchmarking. How Pflua compares to other packet-filtering solutions. Spoiler: it is sometimes several times faster.
• Real-world demo: filtering with pflua and Snabb Switch.

This talk will teach you about Elasticsearch and Lucene's architecture.

The key data structure in search is the powerful inverted index, which is actually simple to understand. We start there, then ascend through abstraction layers to get an overview of how a distributed search cluster processes searches and changes.

Fuzzing can help to find various kinds of bugs automatically. It may also highlight "weak" spots that deserve manual code inspection.

Both FreeBSD itself and the ports we use daily contain bugs that have yet to be discovered and fixed.

American fuzz lop (security/afl) is a fast intrumented fuzzer available in ports.

I'll present a couple of bugs that were already found with it and describe the code modifications that were used to increase the efficiency.

LibreOffice has been using gerrit for some time. This present an on-going effort to integrate jenkins into the mix to provide multi-platform build verification and test as early in the dev process as possible.

This talk will discuss the issues around implemeting LFE (Lisp Flavoured Erlang) on the Erlang VM. The Erlang VM has been specially designed to implement Erlang and as such it has a number of interesting features and limitations which directly influence the design of a lisp running on top of it. We will look at the properties of the Erlang VM and our design goals for LFE and the LFE lisp which this resulted in.

The status of Dancer. Version 1 vs version 2. Development efforts. Progress, lack of progress, and everything in between.

This talk introduces a brand new web server - Ultra. With a binary at just 51K it's small, fast, and encompasses an all-in-memory web server with an in-built NoSQL datastore, a data processing language, SSI, multiple configurations, and logging. If you want to learn basic networking programming, its source is small enough for you to learn from. The talk covers the basic architecture and approach in keeping a small footprint, and breaks down the source into easily understandable blocks.

The talk covers the history and development of a unique project - one that tells a classic open source story about a developer scratching an itch, and solving a problem he didn't have! It covers the code from 47 lines of C, to 1500 of C++. It also details how the processing language was governed by code re-use, and how the data store uses convention over configuration to work efficiently. It's one of the few projects that is small enough to do serious work, but small enough to be explained line-by-line in a talk! (Although it won't be that direct!)

This talk will present the latest developments in GPAC regarding the media production for playback in modern browsers. This will include aspects related to subtitling (WebVTT, TTML) and graphics (SVG) streaming, MPEG-DASH and HTML5 Media Source Extensions, in particular using the MP4Box.js MP4 demuxer.

Producing media content for the browsers using GPAC: Latest developments for media web distribution

This talk will present the latest developments in GPAC regarding the media production for playback in modern browsers. This will include aspects related to subtitling (WebVTT, TTML) and graphics (SVG) streaming, MPEG-DASH and HTML5 Media Source Extensions, in particular using the MP4Box.js MP4 demuxer.

Gerrit Code Review is Git based pre-merged code review tool, used by LibreOffice project. And as thus is heavily used by LibreOffice developers in different roles, either as a contributor or as a core reviewer.

In this talk the long awaited feature (that GitHub and other platforms already support): the ability to create, populate and amend Gerrit changes directly in browser is explained.

Priot to Gerrit 2.11 to address reviewer comments, (even typos) The Gerrit change must be amended in local environment and repushed to Gerrit again.

Starting from gerrit 2.11 changes can be created and edited directly in the browser.

• New changes can be created and populated directly in the browser via a 'Create Change' button on the project info screen.

• New follow-up changes can be created via a 'Follow-Up' button on the change screen

• Content editing takes place in a full screen CodeMirror window with support for themes, syntax highlighting, different key maps (Emacs, Vim, Default).

• The CodeMirror screen can be configured in the same way as the side-by-side diff screen.

• The file table in the change screen supports edit mode with seamless navigation to CodeMirror for editing.

• Edit mode can be started from the side-by-side diff screen with seamless navigation to CodeMirror.

• The commit message can be changed in context of change edit. The 'Edit Message' button is still supported, but now it creates a change edit that must be published.

• Files can be added, deleted, restored and modified directly in browser.

• User-specific configuration dedicated to edit mode in CodeMirror are stored in the All-Users repository rather than in the database.

In this talk i will present the concepts and go into implementation details.

The Intel DPDK provides a platform for building high performance Network Function Virtualization applications. But it is hard to get high performance unless certain design tradeoffs are made. This talk focuses on the lessons learned in creating the Brocade vRouter using DPDK. It covers some of the architecture, locking and low level issues that all have to be dealt with to achieve 80 Million packets per second forwarding.

Building a spreadsheet app with Python is simpler than you think! I'll show you how we can build one with Python, from the ground up, in 15 minutes or less. Fun times with recursion guaranteed.

Have you ever wondered how a spreadsheet works? I was fairly #mindblown when someone first explained it to me on the back of a beermat -- it's simpler than I thought! Let me take you on a tour of the source code for Project Dirigible, an experimental web port of Resolver One, the (sadly defunct) Pythonic spreadsheet. We'll cover formula parsing, identifying dependencies, building the recalculation graph, loop detection, and even some of the mind-bending fun that Dirigible lets you do with user-defined functions.

I propose to introduce the audience to Mozilla's new brand project Mozilla ID. Mozilla ID is a very new project, launched in August 2014 and headed by Mozilla's art director Sean Martell. Mozilla ID aims at developing the core pillars for a new, living Mozilla brand, consisting of a word mark and logo. Mozilla's aim with the project is to allow unlimited variants of the Mozilla logo which will be based on live community data. There will be a logo generator that Mozilla is currently working on where contributors can select the data feeds and colors and it will output SVG versions of the logo for use. People will be able to customize the look based on the options they choose. Effectively, the openness and community contribution that is at the core of Mozilla's software projects will be transferred also to its branding, enhancing community identification on that additional level.

I will first of all introduce the project and will show images to illustrate the ongoing creative development process led by Sean Martell.

Moving on to the protection angle: I will speak about traditional patterns of trademark protection and enforcement and how these are being challenged by the market and marketing realities of our modern times. I will speak about the advantages and appeal of living, or fluid, brands, giving examples (such as Google doodle, MTV, Absolut Vodka, to name but a few). I will point out risks and provide guidance on how a living brand can bridge the divide between valuable community contribution and identification and the restrictions of trademark protection. Essentially, a living brand can have a steady distinctive core which suffices to maintain trademark protection, while certain of its characteristics may be subject to change, community contribution and innovation. The key challenge is to define the core that is to be the subject of trademark protection, without unduly restricting the process of innovation that makes the brand a living brand.

This talk will present how to solve some graph visualization use cases with sigma.js, an open JavaScript library dedicated to graph drawing.

Sigma.js is an open JavaScript library dedicated to graph drawing. It can display some medium graphs (tens of thousands of nodes, hundreds of thousands of edges, under some conditions), using Canvas, WebGL or SVG. Its API has been designed to facilitate the development of Web applications highly customized renderings and interactions as well as the most simple use cases. This talk will show how sigma can solve in action some common use cases, such as: - static graph visualizations: typically a graph that has already been "mapped" and exported from Gephi - dynamic exploration: for instance a neighborhoods exploration of a large graph - customized rendering: for example to make the graphs being displayed with a specific graphic guidelines - customized interactions: to adapt the behaviours to specific UX needs

Website: Repository:

Java is often criticized for its lack of supporting C-style structs. This makes it hard to efficiently implement certain type of data structures (like for example arrays of small objects) in Java.

However, recently there have been several different approaches which try to address this problem. My talk will briefly introduce "Packed Objects", an extension available in IBM's Java SDK 8, "Object Layout", a layout-optimized Java data structure package proposed by Azul Systems and Value Types [3][4], an OpenJDK proposal for immutable, reference-free value objects.

I will describe the commonalities and differences of the three approaches and explain how they can improve the memory overhead and locality of Java objects.

Consul is a Service discovery tool created by Hashicorp, in this talk I will guide the audience through the basics of its functionality and how to take the best out of it.

Consul is a Service discovery tool created by Hashicorp, in this talk I will guide the audience through the basics of its functionality and how to take the best out of it. The talk will be composed of the following parts: 1- What is Service Discovery 2- What is Consul 3- Consul components 4- How does it fit in your platform (cloud, docker, hardware) 5- Advanced functionality 6- Extra modules

There is an increase in popularity of adblockers. Adblock Plus is the oldest and most popular one, with over 50M users. But most people still don't know how an adblocker actually works. In this talk I will attempt to explain how adblocking works, at least how we have implemented it in Adblock Plus.

Learn how other people are using OpenNebula today to deploy clouds in a snap, all the way from micro clouds to massively big, federated clouds. Learn performance and tuning tips shared by other OpenNebula fellow users to leverage other open-source projects like Ceph, LizardsFS, Open vSwitch and Puppet into making your cloud resilient, fast, flexible and massive.

We will also shed some light on other OpenNebula compoments that have grown indispensable to their users, like hooks, AppMarket to share images accross OpenNebula deployments, OneFlow to manage services and OneGate to report metrics directly to OpenNebula.

LibreOffice Writer was always capable of handling complex content in a floating TextFrame, which allows fields, tables, embedded objects and similar features. But what about non-rectangular shapes? Or even rectangular ones, but with rounded corners? TextBoxes is a new concept that allows attaching complex Writer content to a drawinglayer custom shape: having both custom geometry without being limited to simple editeng content. Come and see where we are, what still needs to be done, and how you can help.

JRuby 9000 represents the biggest-ever leap forward for JRuby. Not only have we caught up on compatibility (9000 will be 2.2-compatible from release), but we've completely redesigned our JVM-based runtime and have opened our codebase up to the JRuby+Truffle research project from Oracle Labs. The changes we've made will make it easier to keep up with MRI on compatibility and give us the potential to run Ruby as fast as Java or C. The entire Ruby world will change over the next year, and JRuby 9000 will be leading the way. We'll talk about what Ruby's going to look like once JRuby is "over 9000".

With the complete failure of security forces to contain the impending threat of Perl 6, developers are beginning to investigate it themselves. Unfortunately, many of the combatants who wield Camelia are so enraptured that they post long sermons extolling the virtues of hyperoperators, meta-object protocols, and composable concurrency, scaring off the faithful. Those sermons are important. However, it turns out Perl 6 is actually a fairly easy weapon to use and for day-to-day use, it's simple. This talk will take things down a notch or three and show you how simple basic Perl 6 really is. The talk might even be less objectionable than this description.

A whirlwind introductory tour of OpenUI5, the open source, responsive, enterprise strength HTML5 toolkit from SAP.

SAP open sourced their HTML5 toolkit that is used as the foundation for all SAP's present and planned UI endeavours. It's responsive, enterprise strength, has a ton of features including full MVC support, a powerful data binding system, declarative view mechanics, support for internationalisation, right-to-left and accessibility right out of the box. And it's great to use, too.

This lightning talk will take you on a whirlwind tour of OpenUI5: no slides, just code and activity in the Chrome Developer Tools console.

BERI (the Bluespec Extensible RISC Implementation) is a softcore processor jointly developed by SRI International and The University of Cambridge. It implements a superset of the MIPS III ISA in Bluespec, a high-level HDL and supports a fully open source, permissively licensed, software stack comprising the FreeBSD operating system and the LLVM compiler suite. This talk will describe the design of the BERI processor and its use.

BERI was created to facilitate experimentation at the boundaries between CPU architecture, operating systems, and programming languages. It runs in Altera and Xilinx FPGAs, including the NetFPGA 10G board. At 100MHz, it is fast enough to use as a real computer (albeit a fairly slow one). This allows

There is a close tie between the history of UNIX-like systems and academic use. The original AT&T UNIX was distributed cheaply to universities and so formed the basis of both research projects and operating systems courses for a long time. MINIX, originally free for non-commercial use and now BSD licensed, was written primarily as a platform for teaching and research use and the ties between BSD and UCB speak for themselves. The open source community has benefitted enormously from people passing through university for almost three decades and studying UNIX and related systems.

Compiler development has seen a similar renaissance in recent years, primarily spurred by LLVM, which provides a set of libraries that are easy to use and to modify for building compilers for new languages and new platforms.

The one missing part of the puzzle, so far, has been the hardware. Although we have a plethora of commodity CPUs and even a number of open source designs, these have not typically well integrated into an open source stack.

This talk will discuss the BERI softcore, jointly developed by The University of Cambridge and SRI International and the associated open source software stack. BERI, the Bluespec Extensible RISC Implementation, is a 64-bit MIPS implementation in Bluespec, a high-level hardware description language. It implements the instruction set that debuted in the MIPS R4000 core in 1991, and therefore a set that is free of patents owing to its age. In spite of this, it is a relatively modern 64-bit architecture and is well supported by open source systems. The FreeBSD port to BERI required minimal changes, which were shipped as part of the FreeBSD 10.0 release, and runs unmodified userland 64-bit MIPS code. BERI can run in simulation at a speed acceptable for testing but not for general usage or in an FPGA at 100MHz. The BERI design supports multiple cores on a single FPGA and work is ongoing to support multicore across boards connected with a low-latency interconnect.

On top of this runs FreeBSD, a permissively licensed UNIX variant, and the LLVM compiler suite. This provides a solid platform for experimental use, as users can modify any aspect of the system, from the instruction set upwards. It is relatively simple, for example, to add a new set of instructions as a coprocessor to BERI, add code to the operating system so that the state is preserved across context switches, and add code generation support in LLVM.

BERI provides a generic coprocessor interface, which makes it very easy to extend the functionality. CHERI, Capability Hardware Enhanced RISC Instructions, is a BERI-based CPU that adds a coprocessor providing a capability-oriented memory model. This demonstrates the extensibility of the BERI stack: the CPU, operating system, and compiler have all been modified to provide support for new functionality.

In Jitsi Videobridge (https://jitsi.org/Projects/JitsiVideobridge), a WebRTC video conferencing router, encryption and packet signing were among the most expensive components in terms of CPU intensity. We therefore set out on a journey to optimize them as much as possible.

We would like to share this journey with the Java FLOSS community.

We are going to present a comparison we have made on the execution times of popular open source implementations of AES and SHA-1 in search of the best performer. Our reference implementations are provided by the pure-Java Bouncy Castle cryptography APIs. Our contenders are an assortment of widely-used Java and cross-platform C code: the SunJCE security provider optimized by Java Runtime Environment (JRE) 8, the Mozilla Network Security Services (NSS) libraries employed through the SunPKCS11 security provider and the OpenSSL Crypto library accessed with the help of the Java Native Interface (JNI).

We're going to pit software against hardware in our examination how we can leverage the Advanced Encryption Standard New Instructions (AES-NI).

We're going to look at the performance compromises of transferring bytes between Java and C. Can we beat Java's intrinsics? Will Java New/Non-blocking I/O (NIO) be better?

This talk is targeted at anyone interested in multimedia, whether professionally or as a hobbyist. Be it as an application developer, framework architect, embedded system integrator, or anybody else.

GStreamer is a highly versatile plugin-based multimedia framework that caters to a whole range of multimedia needs, including desktop applications, streaming servers or multimedia middleware; embedded systems, desktops, or server farms. It is also easy to get started with, and is cross-platform, with support for Linux, Android, OS/X, iOS, and Windows, as well as *BSD and Solaris.

In this talk we will present an overview of some of the many different areas and use cases where GStreamer is deployed nowadays and what advantages the use of GStreamer had in these areas. We will talk about web browsers, set-top boxes, mobile devices, live video mixing applications, audio/video editors, broadcasting applications, research of gravitational waves and the International Space Station.

Join us to find out what GStreamer can do for you!

I will explain how CPython objects are built, from simple objects like int or None to complex ones like dict. To make it funnier, I will play to change instance data directly using ctypes and do "really bad things" like truncating tuples.

Recently distributions are often perceived as boring, and working mostly on solved problems, as the focus is moving away to hype stuff such as configuration management or the Cloud. However, distributions are in the best spot to address a number of important challenges -- both old ones that never had a satisfying solution so far, and arising ones. I will describe ongoing work on some of those challenges (mainly in Debian), as well as some thoughts on how we could address other challenges.

The goal of this talk is to review a number of ongoing work in Debian and other distributions, and try to motivate people to work on some important issues. Though centered on Debian due to my experience, I believe that it will be equally valuable for people from other distributions.

Valgrind runs properly multi-threaded applications, but effectively only uses one CPU at a time to run them. In other words, Valgrind cannot make use of multi-core CPUs when running a multi-threaded application.

A prototype of a 'multi-core' Valgrind was developped. This talk will describe this prototype and discuss the challenges to obtain a production quality Valgrind that makes use of multiple core.

This talk shows how languages can be implemented as self-optimizing interpreters, and how Truffle or RPython go about to just-in-time compile these interpreters to efficient native code.

Programming languages are never perfect, so people start building domain-specific languages to be able to solve their problems more easily. However, custom languages are often slow, or take enormous amounts of effort to be made fast by building custom compilers or virtual machines.

With the notion of self-optimizing interpreters, researchers proposed a way to implement languages easily and generate a JIT compiler from a simple interpreter. We explore the idea and experiment with it on top of RPython (of PyPy fame) with its meta-tracing JIT compiler, as well as Truffle, the JVM framework of Oracle Labs for self-optimizing interpreters.

In this talk, we show how a simple interpreter can reach the same order of magnitude of performance as the highly optimizing JVM for Java. We discuss the implementation on top of RPython as well as on top of Java with Truffle so that you can start right away, independent of whether you prefer the Python or JVM ecosystem.

While our own experiments focus on SOM, a little Smalltalk variant to keep things simple, other people have used this approach to improve peek performance of JRuby, or build languages such as JavaScript, R, and Python 3.

The backstory of one of the most remarkable trademark battles in Free Software in recent times. Sri Ramkrishna, Director of the GNOME Foundation and Pamela Chestek, GNOME's trademark counsel will talk about the remarkable 24 hours in a public fundraiser that and the events leading up it.

GNOME's public fundraiser to fight for its trademark will go down as one of the most successful operations by a Free Software project and expression of the political power of the Free Software community. Join Pamela Chestek, GNOME's trademark legal counsel and Sri Ramkrishna, Director of GNOME Foundation and learn how events unfold and how a single tweet started a campaign that ended so remarkably.

Contract-based programming is a software development technique, which is used to find programming errors earlier in the development process. "Contract" refers to formal declarations of how types and subprograms ("functions and methods" if you aren't an Ada programmer already) behave. In the strictest form, the contracts are checked as a part of the compilation process, and only a program which can be proven to conform with the contracts will compile. In a less strict form, it is more similar to "preventive debugging", where the contracts are inserted as run-time checks, which makes it more likely to identify errors during testing.

Ada provides a quite extensive support for contract-based programming. The checks are specified as a mix of compile-time checks, obligatory run-time checks, and optional run-time checks. In addition to that, SPARK defines a subset of Ada with full compile-time checks.

The presentation will introduce the Ada features related to contract-based programming, and provide suggestions for how to make use of the features in practice. It is organized in three main sections: type/object invariants; pre- and postconditions for operations; making the contracts for entire packages consistent. If there is time, the presentation will close with a live test of the guidelines on an example problem selected by the audience.

The intended audience is anybody with enough programming experience to know concepts like types, encapsulation and packages. Having seen source text in Pascal-like programming languages will be a benefit.

The video4linux subsystem of the kernel is a very large API with many ioctls, settings, options and capabilities. This poses a problem both for the kernel developer and for the application developer. Since early 2014 major improvements have been made to both the v4l2-compliance utility for verifying drivers, and to the virtual video driver that applications can use as a reference input. This presentation will explain and demonstrate this utility and driver and show how to use them to ensure your driver or application works correctly.

Digital cameras provide almost every feature you could want. But if they don't, you are forced to upgrade or go without. CHDK is a project which allows you to program new functionality to the majority of Canon cameras, in either C, Lua, or Basic. The talk features background on the project, code, tools, and the methods of compiling and introducing a new firmware into the camera.

Over the course of 1 hour, Steven Goodwin will guide the audience through the entire process of taking a normal (proprietary) camera and converting it into an open source version by installing custom firmware on it. He will then cover some of the features available (such as the on-device scripting language) and continue by explaining how to build and debug your own functionality. Starting with simple grids, continuing with games, and time-lapse code. And ending with a fully recompiled firmware running on the device.

Since the introduction of the Foreign Data Wrapper API in 9.1, things have evolved rather quickly on the SQL-MED front

We will look at the promising things coming (hopefully!) for 9.5 in core, but also at the numerous innovative use-cases for FDW: IMPORT FOREIGN SCHEMA, foreign table inheritance, new ways of storing data, and how to combine those features to use PostgreSQL as an ETL.

The Foreman project and its community is varied, big, and it can take very long to understand what is really going on. Luckily, a group of people is actually working full-time on making it a better project. Contributors often scratch their own itches, and move on.

This talk is meant to give you an overview about areas of Foreman that badly need help, refactoring, and some of the efforts the Foreman community is doing to mitigate technical debt and keep on improving. In short, we want to highlight our flaws so you can target your efforts to the right place.

The Foreman project and its community is varied, big, and it can take very long to understand what is really going on. Luckily, a group of people is actually working full-time on making it a better project. Contributors often scratch their own itches, and move on.

This talk is meant to give you an overview about areas of Foreman that badly need help, refactoring, and some of the efforts the Foreman community is doing to mitigate technical debt and keep on improving. In short, we want to highlight our flaws so you can target your efforts to the right place.

The SDN Community is building network automation along with OpenStack Neutron's capabilities. This creates connectivity based on Linux kernel functions, prevents single vendor solution lock-in and avoids building proprietary data paths. With DPDK and packet processing software to create NFVI, it is possible to keep this openness while both introducing performance and avoiding Neutron plugins for proprietary technologies. In this presentation, Vincent will show how DPDK applications can be combined on the host and guest of the network, and compute nodes of OpenStack scenarios, in order to sustain high performance for north-south and east-west traffic that is required for NFV solutions. 100 Gbps of packet processing throughput examples will be demonstrated.

Down the road, this openness shall apply on any packet processing data plane logic: on x86 hypervisors, ARM CPUs, new IBM Power8 or PCI SmartNICs (Cavium, Broadcom, Tilera).

Vincent will show that in networking, "Open" and "SPEED MATTERS" mean: - keep Linux kernel stack - freedom of Hardware IOs

Around FOSDEM 2015, the first alpha/beta releases of Apache Lucene 5 will likely be downloadable. This talk will present the improvements and new features, but also some incompatible changes in the Lucene 5 release. Lucene 5 will focus on data safety: The move to Java 7 will be completed. Lucene now uses all the brand new features (NIO.2) of Java 7 to make the indexing process more stable and resulting indexes durable. Checksums are used during merging to prevent bugs in the underlying JVM or data corruption due to networking errors (e.g., while distributing indexes during recovery in Elasticsearch) to persist in newly created index segments.

The previous major version, Lucene 4 was a major release that introduced index codecs. In Lucene 5, the API around codecs will be cleaned up and will likely get more stable. There are also new features, like a common FilterCache that can be reused by Solr and Elasticsearch.

In parallel Apache Solr 5 will be released, the first version that will now work as a server out of the box, so Solr is no longer exposed as a webapp. Init.d scripts are included and configuration is managed easier through Zookeeper.

GCC-MELT see http://gcc-melt.org/ for more is a Lispy domain specific language (and GPLv3+ implementation, as a GCC meta-plugin) to extend and customize the GCC compiler (see http://gcc.gnu.org/ for more)

This talk (for people familiar with Lisp, but unfamiliar with GCC internals) will describe the MELT dialect, the implementation challenges, and some MELT usage, with the future directions within the MELT project.

MELT is a Lispy domain specific language to ease the customization of GCC thru particular extensions (notably for additional coding rules checks and diagnostics, or for additional application-specific optimizations).

MELT is a bootstrapped Lisp implementation (of nearly 100KLOC of GPLv3+ source code), compiled to C++ code fit for GCC internals. The MELT dialect has several pecularities: it offers both first-class values and other stuff as data kinds; it provides useful language features (pattern-matching, introspective reflection, meta-programming with macros) for powerful GCC customization.

MELT is integrated inside GCC by being a GCC meta-plugin. It enables adding new GCC optimization passes. We describe some implementation challenges and how we tackled them.

Calc has undergone some revolutionary changes in recent years to improve parallelism and enable OpenCL calculation, I'll explain this base-line that we've reached. I'll then explain recent improvements from Collabora in the dependency engine to further accelerate computation, and to shrink memory usage of the spreadsheet. Then we'll look at the next steps, and where you can get involved.

BSDRP is a software router based on FreeBSD

Here is the Agenda:

• Why a software router ?
• Presenting nanobsd
• Feature list
• Benchmarking forwarding performance
• Virtual lab

Cinder is the block storage solution for Openstack. It has been around for 2 years, and has become a stable and useful part of the Openstack infra-structure. This talk gives the history of Cinder, the current challenges being worked on and some blue sky ideas for where it could go.

Hack is a new programming language from Facebook. It is the natural evolution of PHP. This talk will cover some of the problems with PHP, the benefits of a compiled and statically typed language and then introduce Hack and HHVM as a solution. Half way into the talk I will give a crash course in Hack and explain its perks and syntactic sugar. At the end I'll give some advice on how and where to get started testing Hack.

We have all got used to memory being essentially infinite, however the IoT reopens the constrained device with devices having 256M or less. This project looks at developing an ARM microJIT targeted at these devices. The project is based on the original work I did on the Thumb2 JIT (FOSDEM 2010).

The project targets the Raspberry PI which is an ideal IoT development/demonstration platform. Unfortunately the Thumb2 JIT does not support the Raspberry PI because the Raspberry PI does not have the Thumb2 instruction set. This is a project which I am working on in my 'free' time and I hope to have a demonstrable port by FOSDEM.

Finally I would like to have a discussion about the future of this work.

How Vimeo plays nice with the open source community.

The Vimeo magic is a wonderful collection of Open Source multimedia tools, all able to talk together, whether processing video or audio or images. But what really matters in the Open Source philosophy is the people who are behind this incredible movement.

In this presentation, we will explore how Vimeo leverages open source and how healthy it is to give back to the community whenever possible. Many Vimeo developers are also members of relevant Open Source projects, taking part in application and API design, maintainability and infrastructure discussions.

Most people know Gunicorn as a Python WSGI HTTP Server engine, but a lot ignore it can be used for more usages. With this talk you will discover how you can use it to fit your own needs/business or simply distribute extensions for it.

Most people know Gunicorn as a Python WSGI HTTP Server engine, but a lot ignore it can be used for more usages.

This talk will show you how you can use the current Gunicorn version for different usages, from embedding it in your application to extend it with your own TCP workers or logging modules. This talk will also provide a quick glance (with demo) of the new gunicorn engine, a fully featured process and sockets supervisor engine allowing more customisations.

It is time for Apache OpenOffice to change direction and focus outwards, including collaboration with other projects. Leaving all the non-technical issues out, we will discuss what the technical ones are and how they can be solved.

An important part of building a virtual datacenter is networking. The common wisdom in the field is that providing virtual layer 2 networks built using one of the many open source vSwitches is the correct approach. This talk covers Project Calico, an open source attempt to provide an alternative approach by re-architecting the data center in the image of the Internet, aiming for simplicity, scale and efficiency.

CockroachDB a distributed database written in Go.

Many NoSQL databases come with a focus on performance, availability and scalability, sacrificing strong consistency guarantees along the way. In effect, this shifts the burden of providing consistency to the application, and often results in complex and error-prone application logic. Just a few years ago, an intense effort by Google resulted in Spanner - a globally distributed, replicated datastore that puts transactions back where they belong: right into the heart of the database.

CockroachDB is a grass-roots effort to bring to the table the guarantees of Spanner (and more) in an open source scalable database that is easy to deploy and, despite the name, quite attractive to have around.

Every spring, there's a new version of perl. Every new version of perl ships with "perldelta," the comprehensive list of changes in that version. Every summer, rjbs (the Perl 5 project lead) tries to summarize the perldelta, omitting the tedious and obscure in favor of the awesome and exciting. This winter only, you can get a sneak preview of the yet-unreleased Perl 5.22's planned changes, a recap of the best bits of 5.20, and the faintest whiff of changes under discussion for next

With the current Structr version 1.1, you can use deeply nested JSON documents to create graph structures in Neo4j. In this talk, I will demonstrate how to use Structr and Neo4j as a document database and explain how it works under the hood.

JRuby+Truffle is a new high performance implementation of Ruby being built as an open-source research project at Oracle Labs. It uses state-of-the-art research into techniques for writing interpreters and dynamic compilers that allows it to be both significantly faster than any other implementation of Ruby, but also conceptually simpler.

In this talk we'll explain how JRuby+Truffle works. We'll cover the whole system from the parser to emitting the actual machine code bytes - and we won't have to leave our Java IDE to do it.

We won't shy away from technical depth where it's needed to uncover all the details, but Truffle is designed to be a high-level and simple system accessible to non-experts. Novices will get an insight into the big ideas, and experts will be able to find out how it all really works.

Traditional searches take the form of individual queries over large mostly-stable corpuses of documents. In this talk, we'll show how we invert this paradigm to allow for searching over streams of documents by combining Samza, a distributed stream-processing framework, with Luwak, a library for efficiently running large numbers of queries over individual documents.

Real-time searching over streams is useful in a number of contexts. For example, companies may want to detect whenever they are mentioned in a news feed; or a Twitter user might want to see a continuous stream of tweets for a particular hashtag.

Luwak provides a mechanism for running many thousands of queries over a single document in a highly efficient manner, by filtering out queries that it can detect will not match. Luwak is designed to run on a single node, holding all registered queries in RAM. Scaling to higher document throughput, or to more queries, requires parallelization across multiple machines.

Samza provides a framework for such parallelization, by partitioning and recombining both the document streams and the query set (which can be treated as just another stream), and also provides fault-tolerance mechanisms that allows swift recovery from machine failure, without losing documents or queries.

Introduction to WebRTC and application development using Python on the server side. Let's build a "Call Roulette"!

WebRTC is a recent technology present in modern web browsers allowing developers to create rich multimedia applications using realtime audio, video and data. This talk will give an introduction to WebRTC and walk through the implementation of a simple Call Roulette application, designing the necessary signaling protocol and implementing it on the server side using Python3 and asyncio.

GCompris is a high quality educational software suite comprising of numerous activities for children aged 2 to 10. It was created in 2000 using the GTK+ graphical toolkit. It is available on different platforms, GNU/Linux, and the proprietary platforms MacOSX and Windows.

Willing to address the large number of tablet users and to enhance the user experience the choice was made in January 2014 to rewrite GCompris in Qt Quick.

The presentation will address the following topic:

• Project goal and history
• Community and commercial. Starting in 2003 a Windows version was created and is distributed under a commercial model while being still Free Software. We will see how and why we decided to do so
• Why we selected Qt Quick. This development toolkit is based on Qt and let the developer create dynamic user interface that can run on desktop and mobile platforms
• Why we became a KDE project. GCompris has always been a community project, leaving the GTK+ toolkit it does not make sense to develop the new version under the Gnome umbrella
• State of the Qt Quick port

This talk will present some of the automated tools that the LibreOffice project is using to improve the quality of the code. This includes coverity where the LibreOffice project managed to reach a nearly perfect defect density score of 0.00 and the import/export crash testing with about 75000 documents.

IgProf is a GPL, general purpose, cross platform (x86_64, x86, ARMv7-A, ARM64/AArch64), memory and performance profiling tool originally developed 10 years ago in the context of LHC experiments at CERN (*), to enable optimisation of simulation and data acquisition software. It provides detailed, call-stack level, information on where time / energy is spent and memory allocations happen using a variety of techniques varying from dynamic instrumentation to sampled profiling. While not dissimilar from other similar softwares like Google perftools it was specially tailored to profile extremely large C++ applications comprising millions lines of codes, loading thousands of dynamic libraries and with a very high memory allocation frequency. In addition, ease-of-use and the ability to easily share performance profiles between distributed collaborators are important aspects to enable use by a large community of scientists with varying software development skills.

We present our experience about profiling and improving performance of large applications, discuss similarities and differences with other similar tools and show a few of the new features we have been working on lately, in particular ARM64 support and energy profiling via a PAPI add on. We also show how we gave back to the opensource community by providing patches to libunwind for both x86 and ARM.

(*) CMS is one of the flagship experiments at CERN, a collaboration of over 4000 researchers distributed in more than 100 institutes around the world. They use a distributed computing architecture consisting of more than 100K x86-64 cores to answer questions about the origin of the universe and the structure of matter. Given the scale of the computational resources, software performance optimization is a critical need.

FreeCAD is a general purpose, open-source, multiplatform parametric 3D modeling application, geared mainly for product design, in other words anything that is meant to be built in the real world. The project started around 2002, and is today entering a a big momentum with the blossoming of home 3D printing and manufacturing, and thanks to is extreme hackability.

FreeCAD can be described as a big, modular "collage" between many heavyweight open-source libraries and projects, such as OpenCasCade (our geometry engine), Coin3D (an implementation of OpenInventor, which drives the 3D display), Qt and Python. But it can also, more accurately, be called a "python beast". With a bit of knowledge of the python language, its user is given the powers of a God.

Although programmed mainly in C++, python is everywhere in FreeCAD: It acts as a "glue" between the "core" part of the application, which handles all the heavy geometric calculations, and the Qt graphical interface. This offers a wealth of interesting features such as the separation of FreeCAD into a non-GUI (server mode) part and a GUI part, possibilities to record, tweak, drive, or interact with the python flow in many ways, and much more. Each of the main libraries used in FreeCAD also has its own python bindings, all usable inside FreeCAD, all connecting to the running application and able to operate on its contents, its objects, its interface, its 3D display.

Python code in FreeCAD is also constantly exposed to the user, turning the application very pedagogic. It is almost impossible to work with it without learning at least a bit of python. Many have tried.

This has formed a highly technically knowledgeable community around FreeCAD, where the differences between developer and user have blurred.

This talk will try to convey some of the amazing social/technical experience we have building this tool that is made to build.

This talk will explain how to deploy OpenStack using the Xen hypervisor to run your virtual machines.

It will start by describing the OpenStack architecture and its most important components. It will go into details on how to use DevStack to setup an OpenStack development environment based on Xen and Libvirt. It will also cover the most popular and robust deployment schemes for OpenStack with Xen and Libvirt aimed for production servers, including Ubuntu packages from the latest LTS, Chef and Puppet.

The audience will learn the most important OpenStack and Xen config options, the pitfalls to avoid in their deployment and how to tweak both of them to get the best performance and stability out of your OpenStack cloud.

What's with Emacs? Its design makes user freedom more practical by putting all the mechanics at the user's fingertips. This talk will explore how GNU Guix and its distribution seek to empower users in a similar way.

The very design of Emacs empowers users: the whole documentation and source is at their fingertips, ready to be debugged or changed for immediate effect. Free software made practical!

What about following that Emacs meme for a complete distro? That's what the GNU Guix project has been trying to answer. The project has been developing a package manager and associated GNU/Linux distribution over the last two years. By using a general-purpose implementation language, Scheme, and by specializing it to offer high-level abstractions, Guix and the Guix System Distribution (GNU GSD) empower users by blurring the distinction between packagers and users, and by offering a uniform, hackable framework.

This talk gives an update of GNU Guix, and gives insight into how its design and implementation attempt to enhance software freedom.

We will see how users can fiddle with these foundations without having to cross barriers imposed by complex C systems and the historical baggage of a flurry of loosely integrated scripts and tools of varying languages. The talk will also demo features that set Guix apart from many other tools: supports transactional upgrades, rollback, per-user installations, reproducible operating system declarations, and more.

This talk will cover the reasons Samba moved license from GPLv2+ to GPLv3+, what we gained as a community out of it, and also the downsides we have experienced from the decision. This talk should interest any project thinking of moving to GPLv3 from an existing license, and also projects considering a new license.

This talk will cover the reasons Samba moved license from GPLv2+ to GPLv3+, what we gained as a community out of it, and also the downsides we have experienced from the decision. This talk should interest any project thinking of moving to GPLv3 from an existing license, and also projects considering a new license.

In this talk, I'll illustrate and analyze the health of the top configuration-management software, as well as making data-driven predictions and looking at major showstoppers. I'm going to draw comparisons across communities as well as within them, to make it clear where the critical mass and acceleration are.

Drawing on data from a wide variety of sources like GitHub, Stack Overflow, bug trackers, external modules, and mailing lists, I'll illustrate and analyze the health of the top configuration-management software. By looking at historical data, we can also make some rough predictions about future directions as well as pitfalls to avoid. I'll draw comparisons across communities like Puppet, Chef, CFEngine, Ansible, and SaltStack to help you understand where things stand today and where they're headed in the future.

This presentation will cover the new features in VLC 2.2.0 and 3.0.0 that we introduced.

It will cover also the updates in libVLC APIs for developers

This presentation will cover the new features in VLC 2.2.0 and 3.0.0 that we introduced.

It will cover also the updates in libVLC APIs for developers.

Memcheck's performance is significantly limited by the need for the JIT generated code to call a helper function for every memory access. This talk will describe ongoing work to inline the fast cases of these helpers into the generated code, with the goal of getting a significant speedup.

Valgrind's Memcheck tool performs address checking at the byte level and definedness checking at the bit level. Most of the definedness checking code is generated by Valgrind's JIT (VEX) as in-line code. But address checking is done by calling small C helper functions. That means one function call for each memory access to be checked, which is expensive. And it's wasteful because those checks are actually very simple, so the overhead of the calls is significant.

This talk describes ongoing work to inline the fast paths of such helper functions into the generated code. The fast paths deal with the common case -- naturally aligned addresses and fully defined values -- with all other cases being pushed "off-trace" onto cold paths, possibly with helper calls to C land.

Modifying the until-now simple JIT to support the arbitrary control flow this requires would be a big and complex task. Instead we use a system of machine code templates which allow precise control of branching and register use without significantly complicating the JIT. Making the templates architecture-neutral yet capable of generating good straight-line code is an interesting challenge.

In 2014, AdaCore has released two new components in the GNAT GPL Edition: GNAT GPL for ARM Bare Board and SPARK 2014. I present the content of GNAT GPL for ARM, its Ravenscar runtime, how to build and deploy an embedded application in Ada and how it was used to teach Ada.

Two different demos will be presented: a Tetris game and a train signalling system. Both are fully written in Ada, with some parts written and proven with SPARK 2014.

Haka is an open source, security oriented, language and framework that allows to analyze live (or captured) traffic and easily dissect and modify it. Haka is based on Lua which is a simple, lightweight and efficient scripting language. The goal of Haka is to simplify the writing of network filtering rules using a common high-level language, hide the complexity of network protocol dissection to the end-user while still allowing complex tasks (such as packet injection) to happen transparently on a live stream.

This presentation will introduce HAKA's capabilities and show some examples of data manipulation both at the packet and at the stream level. An example of packet dissector and grammar implementation will also be shown to demonstrate how protocol management is handled in Haka

more information at http://www.haka-security.org/

The video4linux kernel subsystem reports which colorspace the captured video uses. But what does that really mean, and what do you have to do to correctly reproduce those colors? This talk will dive into the crazy world of colorspaces and give you a practical guide to colorspace handling. I will also demonstrate colorspace handling, both right and wrong.

SQL has gone out of fashion lately—partly due to the NoSQL movement, but mostly because SQL is often still used like 20 years ago. As a matter of fact, the SQL standard continued to evolve during the past decades resulting in the current release of 2011. In this session, we will go through the most important additions since the widely known SQL-92, explain how they work and how PostgreSQL supports and extends them. We will cover common table expressions and window functions in detail and have a very short look at the temporal features of SQL:2011 and the related features of PostgreSQL.

During the last year (2014) a lot of interesting development happened around the FreeBSD/Xen port. FreeBSD slowly moved from running as a PV with HVM drivers, to running as a PVHVM guests and finally as a PVH DomU. The last step into getting full Xen support into FreeBSD was to get it to run as a PVH Dom0, which is now finished and in a tech-preview status.

This talk will include a high-level description of the modifications needed in order to get FreeBSD running as a Dom0, and a demo of FreeBSD running as a PVH Xen Dom0.

The goal of this talk is to provide information about the Xen PVH and FreeBSD architecture, and to encourage other OS hackers to work on it.

• Basic Xen description and specific Xen concepts.
• How the Xen community works (compared to BSD communities).
• A look into new Xen features (PVH).
• Work being done in FreeBSD improving Xen support.
• Demo of a FreeBSD PVH Dom0.

In this Lightning Talk we want to present “Requirements Bazaar 2.0” that aims to be a social continuous innovation platform to bring developers and end-users together. In years of research we have developed and actually operated an open innovation platform for gathering requirements for prototypes in large international academic projects. The last version of the current product is available under http://requirements-bazaar.org . End-users can enter their requirements by providing short descriptions including user stories, screenshots and other images. The requirements can then be shared amongst its users. On the other side of the chain, developers may take up ideas and transfer the accepted requirements to an issue system like JIRA.

Over the last years it turned out that people want more lightweight and mobile-friendly tools; we found the old monolithic system to be very hard to maintain to add new features. Therefore we are currently redeveloping it from scratch integrating many ideas from our users and incorporating new research findings. We are further driven by a mobile-first approach to support a wide variety of devices. We additionally want to support various social features like sharing on social networks or blogs and allowing discussions and rating amongst end-users and developers.

At FOSDEM we would like to encourage open source developers in rethinking the way requirements are currently gathered from the crowd. How do we want to collect new software ideas or simply feature requests from our users. Will it really be through feedback forms in our apps’ “About” menu? Do our users really think in terms of issues like we developers do? How can gamification be used to reward actual end-users of software? We hope Requirements Bazaar can answer these questions and fill the gap!

The main backend part can be found at https://github.com/rwth-acis/RequirementsBazaar while the Web frontend is hosted at https://github.com/rwth-acis/RequirementsBazaar-WebFrontend

We use a Java backend based on microservices and an AngularJS/Polymer based Web frontend.

Good software can take a hit. Most software can't. The OpenDocument Format (ODF) specification is quite large and very important. Now that it is being adopted more and more, many strange and wonderful documents will be created by custom software that claim to be ODF documents. The ODF softwares of the world should be prepared. That's why ODFAutoTests helps you to create outlandish documents and lets you run them through your software.

This talk will include an enticing argument for writing tests and will present the audience with the data of running the current tests on the current software.

Puppet is a tool for configuration management and automation. It’s written in Ruby, and therefore its codebase contains a notable lack of parentheses. So, we set out to solve that problem and wrote Puppet Server: a new, open source implementation of the Puppet Master, written in Clojure. In this talk, we’ll discuss the development of Puppet Server, our experience with Clojure, and some of the dragons slain along the way. I’ll also give an introduction to Trapperkeeper - an open source application framework for Clojure programs, which we developed along the way.

What really happens to your Java code along the way to becoming machine code?

Red Hat has been developing an almost pauseless GC for OpenJDK which requires adding read barriers to every object access. We've also developed ARM64 versions of both the server and the client compilers. This has given us quite a bit of experience with the internals of the various methods of generating machine code inside the JVM. This talk will start with a brief tour of the various levels of code generation available and then open up the floor for questions from our panel.

This talk brings together presentations from three very popular web players Video.js, JwPlayer, and Kaltura Player ToolKit. Collectively these project represent a huge percentage of online video views and enable video robust video delivery for many content makers around the world. In this presentation, each project will present it’s architectural approach to contemporary multi-screen, multi-browser video playback. Projects will highlight how they work with the open source community and with tips for integration into your applications or websites. After the short presentations there will be a chance for QA for the projects.

Python applications sometimes need all the performance they can get. Think of e.g. web, REST or RPC servers. There are several ways to address this: scale up by using more processes, use Cython, use PyPy, rewrite parts in C, etc.

However, there are also quite a few things that can be done directly in Python. This talk goes through a number of examples and show cases how sticking to a few idioms can easily enhance the performance of your existing application without having to revert to more complex optimization strategies.

The majority of NoSQL meetups in London are hosted on meetup.com and luckily for us meetup.com has an API that allows us to extract all the corresponding data - groups, events, venues, members and RSVPs.

In this talk Mark will show how we can use R to gain quick insights into the data using tools like dplyr and ggplot2. We'll also do some social network analysis of the attendees of London's meetup scene using igraph.

Finally we'll look at how we could bring together all these insights into a brand new Clojure front end for the meetup website.

The majority of NoSQL meetups in London are hosted on meetup.com and luckily for us meetup.com has an API that allows us to extract all the corresponding data - groups, events, venues, members and RSVPs.

In this talk Mark will show how we can use R to gain quick insights into the data using tools like dplyr and ggplot2. We'll also do some social network analysis of the attendees of London's meetup scene using igraph.

Finally we'll look at how we could bring together all these insights into a brand new Clojure front end for the meetup website.

VXVDE does not require any program to dispatch packets: vxvde has been implemented as a module of the libvdeplug library. It does not need any infrustructure other than a well configured IPv4 or IPv6 network supporting IP multicast. VXVDE has a very simple configuration. A valid IP multicast address is enough to configure a "switchless switched" virtual network.

Unlike VXLAN, VXVDE does not require any Virtual Tunnel End Point (VTEP). Virtual Machines manage their own access to the virtual network. VXVDE unicast packets are mapped on UDP packets traveling on a direct path from the sending virtual machine to the receiving one, without any copy, any packet retransmission or extra header.

Every time a question of speed or production readiness comes up, the answer always seems to be somewhat evasive -- "depends on what your production is", they say, or it's fast enough for my use case". Let's see how it works with computer games, where you can't easily cheat with pre-rendering or caching to workaround things being slow.

The oVirt project allows efficient management of virtualized datacenters. Deciding what machine should host a certain VM is one of the important functions of the management platform. Unfortunately it is also one of the complex ones, because there can be many rules governing the placement policy and there is a time limit in which a VM has to be started or migration initiated. Till now each VM was considered separately and that caused fragmentation of free resources.

We are about to present a new solution to this issue in this presentation. We have started a cooperation with the OptaPlanner team that develops an optimization engine based on probabilistic (soft computing) algorithms. This means that oVirt will feed situation updates to an optimization service and continuously receive improved solutions back. It will then use the precomputed results for rebalancing the clusters.

The talk will describe the problems of scalability for libre video conferencing and how they are being addressed by the new video routing architectures. It is gong to go over optimization techniques such as Last N and Simulcast. The presentation is going to then go over the Jitsi Videobridge FLOSS video router and talk about how developers can use it in their video conferencing applications.

Until recently high quality, multi-party video conferencing has been an ever elusive dream to many of us. While it has existed for tens of years already, it has always been been prohibitively expensive and a luxury that only rich corporations could afford.

Readily available broadband, has opened up new horizons in the field however. The traditional video mixing servers (MCUs) are becoming irrelevant today and are being replaced by infinitely more scalable video routers, also known as Selective Forwarding Units (SFUs).

Google Hangouts and the underlying Vidyo technology they used, have been one of the more popular examples in the past couple of years. Early 2014, jitsi.org also released Jitsi Videobridge, an open source video router (SFU) that is compatible with WebRTC and that allows FLOSS developers around the world to start building scalable video conferencing applications.

This lecture is going to go over some of the more important concepts of scalable video conferencing, such as selective routing, simulcasting and layered video, RTCP termination and others.

We are then going to look into the privacy issues related to video conferencing today, discuss the possibilities for truly confidential multi-party calls and the interesting impact, both positive and negative, that WebRTC has on the possible solutions.

LibreOffice 4.4 has got many user interface improvements - but there's still much more to do. Come and hear how you can get involved, and can help make LibreOffice more usable & more beautiful!

MRI vs. Father Time

Matz Ruby Implementation has grown into a fast and effective option for building dynamic applications. Thanks to the advancements such as YARV virtual machine and Incremental GC introduced in Ruby 2.2.

In this talk we will cover the Past, Present and Future of the MRI interpreter. We'll see how it performs under various conditions, such as static content generation and web services.

With the help of new and improved MRI tooling, you'll get to see the path to profiling your applications and enlightenment.

Join the author of MRI’s new Virtual Machine and Garbage Collector Koichi Sasada along with Terence Lee and Zachary Scott. As they dig through the internals of Matz Ruby Implementation.

EBISearch is a text search engine providing access to biological data resources hosted at EMBL-EBI. We will speak about the history of this engine, the infrastracture used, some statistics and future plans.

EBISearch is a text search engine providing access to biological data resources hosted at EMBL-EBI. These Lucene indexes are organized in a hierarchy and we offer an easy 'inter-index' (or, in Lucene terms: inter-domain) navigation via a network of cross-references.

The data resources represented in the EBI Search engine include: biological sequences, chemicals and macro-molecular structures, bio-medical literature abstracts and meta-information related to biological entities (e.g. genes, transcripts, proteins, etc.)

The EBISearch evolution/development is influenced by the EMBL-EBI IT infrastructure, which is designed to cope with great amount of data and relies on technical choices about data storage on network/distributed filesystem and heterogeneous type of hosts.

The EBISearch engine provides search accross ~1.1bn documents updated to the last biologial data available; we will provide some statistics about the amount of data we index; indexing parallelisation and the lifecycle of these indexes.

At search time the engine organize the indexes in a hierarchy and searches are executed across most domains. This allows us to benefit of homogeneus score across the indexes. We rely heavily on the use facets for filtering results (Lucene taxonomies)..

EBISearch usage is monitored and analyzed through our application logs as well as web logs; we will present some statistics about usage and discuss which kind of theme we are looking into; the focus is in understanding usage patterns to drive our next development.

In the future, we need to explore how to cope with the increasing volume of data that are being generated in the bio-medical fields and on how to handle requests for new functionalities; for these reasons we will investigate the usage of other technologies and existing search engines based on Lucene. We are also interested in different types of data visualization and we will briefly present what we have done in this area.

Copyleft licences work by conditioning distribution of a work's binary on providing access to relevant source code. Under the European Computer Programs directive, once a copy of a computer program has been placed in circulation in the EEA by or with the consent of the copyright holder, the copyright holder can no longer control circulation ("exhaustion of rights"). Is the condition to provide source an attempt to control circulation, and is the exhaustion principle problematic for the GPL and other copyleft licences? Commentators have suggested that this is fatal to copyleft, but we argue these analyses are overblown.

CBS is the community build system for CentOS Special Interest Group members.

The service allows to build package with Koji, the open source Fedora project, against CentOS 5, CentOS 6 and CentOS 7. Details for leveraging and adapting existing tools to build RPMs from git repositories will be given.

The process uncovered challenges about both RPMs building and their final distribution, we will review them, along with solutions and what remains to be done.

Finally, the supporting infrastructure will be described and key choices highlighted.

In an agile world, building RPMs and distributing them in a clean and fast way is more and more important for all system administrators. Providing users with a simple interface and an easy way to deploy test packages, validate their software functionality and finally distribute them is very important.

Koji is the software that builds RPM packages for the Fedora project. It uses Mock to create chroot environments to perform builds. "Koji" installation and management will be detailed with a review of needed patches.

"fedpkg" is the command line software for Fedora developers. It interacts with dist-git, koji, rpmbuild, git. "centpkg" provides CentOS specific configuration to interact with CBS Koji instance and git.centos.org. Both tools are based on rpkg ; a python library (pyrpkg) and example runtime script to interact with git repos housing rpm spec files building through koji like build systems.

An additional challenge is to distribute in well organised repositories the resulting signed RPMs. The adopted process will be detailed,

An insight in the infrastructure needed for building, distributing and signing will be given.

If you always wanted to hack on Valgrind, but haven't yet really looked at the code yet, then this talk is for you. We'll go over setting up the sources to start hacking, where to start and explore various easy hacks by example. After attending this talk, you should be all set to attend the hackaton in the Valgrind devroom at the end of the day.

The Netlink protocol is a Linux framework, that implements an easy to use communication channel between the kernel and userspace. This discussion is planned to highlight some common Netlink issues and practices, that can be interesting to other low-level network related projects.

The purpose of the pyroute2 project is to provide [not only] Python developers with a simple and reliable Netlink library, which could be used for the network setup as well as for the traffic processing, or even process monitoring and audit. While implementing it, we've met a number of issues coming from different parts of different Netlink subsystems. No one of the issues is a bug sensu stricto, but all of them seriously affect the final implementation.

So, it would be nice to share and discuss shortly the experience of the implementation solutions. Almost every low-level network related project has to work with the Netlink features and issues, and some of this knowledge can and, probably, should be generalized.

The agenda of the discussion is to show Netlink tricks and their impact on different levels: from the lowest protocol level to the high-level OS network setup. Will be prepared a demo of different projects interoperability, including Netlink proxying.

Orchestration is a hot topic today. Juju has been tackling the issue of orchestration for the past four years. In this talk we'll cover how Juju handles orchestration, how Juju can fit in to your existing stack, and demonstrate how Juju can orchestrate common deployments.

Using XMPP on resource constraint systems, like Android devices that are surrounded by a hostile mobile environment, imposes many challenges. But with the right measures a stable, reliable, push-enabled and battery friendly connection can be achieved. This talk will present the required techniques using Smack, an open source XMPP client library written in Java. One outstanding property of Smack is that it's a multi-runtime library, i.e. it is able to run on Java SE runtimes and on Android.

XMPP on Android is challenging. But with Smack there exists an open source XMPP client library written in Java, that is able to run natively on Java SE runtime environments and on Android. Smack is a lightweight, resource friendly and highly modular library. Ideal for the deployment in low-end devices. But the mobile usage scenario of Android devices poses another obstacle towards a stable and reliable (mobile) XMPP connection. Data connectivity changes, caused for example when a GSM ↔ WiFi switch happens, and high latency, are just some effects of such a mobile environment. With XEP-198 Stream Management, XMPP provides the ideal extension to tackle those issues. Using XEP-198 Stream Management enabled connections, data connectivity changes become transparent to the application.

Another obstacle imposed by Android is caused by the device entering the so called "deep sleep" mode. While incoming radio activity usually causes the device to leave the sleep, it's not guaranteed that it will not re-enter the sleep before the XMPP stanza has been fully processed. There are some forms of possible mitigations conceivable. But which are good? And which are just snake oil?

I'll start with a short introduction of XMPP and Smack and explain how Smack is able to target Android and Java SE runtimes. The rest of the talk will consist of best practices using Smack on Android and how Smack can be used for stable, reliable XMPP connections and push notifications.

The Document Liberation Project has already developed a dozen of import libraries which have been integrated by software such as: Abiword, Calligra, CorelDRAW File Viewer, Inkscape, LibreOffice and Scribus. Besides short overview of motivations behind the project creation, this lecture will present the technical details of the framework used by the Document Liberation Project, as well as the different home-brewed introspection tools that we use. This are all free software tools that can be of use for wide range of other FLOSS projects.

Kernel profiling tools status on ARM and ARM64: - perf status, - ARM and ARM64 support, - callchain unwinding mechanisms and support, - patches status: merged, pending, in development, - links to discussions (LKML) and patches.

The profiling tools in the kernel are changing at a fast pace. This talk is about the support for ARM and ARM64 architecture and the development of features for these architectures, namely the callchain unwinding. The presentation goes over: - the detailed description of the feature, - the methods used to do the callchain unwinding (fp, exidx, dwarf etc.), - the status of the on-going patches, - the remaining work to be done, - the links to patches, discussions on the mailing lists, - -if needed and if time allows- a demo of the feature.

The apt.postgresql.org repository hosts PostgreSQL server packages for seven major releases: all the stable branches plus beta and the devel versions. Targetting two architectures and seven Debian and Ubuntu releases, this is almost 100 combinations in the cross product. On top of that, we build binary packages for various PostgreSQL extensions and applications. Of course no one is able to test thousands of packages manually.

We are putting much effort into running regression tests on all extensions using pg_regress, and creating system integration tests to be run with the autopkgtest tool. All tests are integrated with our Jenkins build server.

This talk presents recent advances made in the area and includes examples of bugs found.

Emacs contains one of the most widely used Lisp dialects, Elisp. As the preferred text editor for a multitude of software developers, Emacs has been ported to a wide range of platforms. Recently, Emacs has come to the Web by way of a technology called Native Client. This talk explores the unique challenges of porting Emacs and Elisp to Native Client and the browser.

Native Client (NaCl), is an open-source technology that allows native machine code to run securely sandboxed in the browser. Two layers of sandboxing, a static verification inner sandbox combined with Chrome’s outer process sandbox, ensure users can safely run untrusted applications. Modified GCC and an LLVM based toolchains allow applications to target NaCl. An I/O API called PPAPI, mirroring the security constraints of Javascript, is provided to NaCl applications.

This talk will focus on the challenges of porting Emacs to NaCl including: emulation of POSIX APIs—processes, sockets, files—on top of Web-centric APIs, porting an X11 server and client libraries, adapting Elisp to NaCl’s memory layout, and packaging for an integrated experience. I will talk about the challenges of debugging the lisp that is a part of the editor itself. I’ll demonstrate Emacs running in Google Chrome and explorer how it can interoperate with other developer tools we’ve ported to the browser.

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

In the previous two episodes, we showed how Ada makes it easy to turn a single-threaded program into a multi-threaded program. We ended up with ten thousand threads working concurrently then introduced a task pool and work queue wherein a small number of threads (one per processor core) process thousands of small work units. But the work queue could become very big. In this third and last episode, we show how to restrict the size of the work queue to a fixed limit, thereby preventing denial-of-service attacks.

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

Discussion of the motivation for explicit sync points and how we're implementing them in the Intel gfx driver, called i915 in the Linux kernel sources.

Explicit synchronization APIs like NVfence or ARBsync allow rendering clients to manage their GPU usage explicitly, rather than relying on an underlying implementation to implicitly synchronize activity reading and writing multiple buffers. In cases where the low level driver (generally in the kernel) doesn't have information about buffer usage, an explicit synchronization mechanism becomes necessary, and in the current i915 environment of implicit synchronization, an additional explicit API can still be useful for tracking performance, non-rendering activity like mode sets, and explicitly queueing unsynchronized activity that an implicit synchronization approach would prevent.

Modern compiler optimization can take almost any code and produce a reasonably efficient binary at the end. However compiler "optimization" doesn't make your code "optimal", just better.

In contrast, superoptimization can produce perfect code - the fastest, the smallest or the most energy efficient code. The technique, first introduced in the late 80s found in some cases it could do 25% better than the best assembly programmer, and 40% better than the best compiler at the time.

Free software has always played a central role in superoptimization research, with the GNU Superoptimizer being one of the very first tools constructed.

However there is a downside. Superoptimization today is incredibly demanding of compute time, so currently it is limited to short instruction sequences. At present it is most valuable in optimizing code hotspots and key library routines, and can also be a valuable aid to the compiler writer for peephole optimization. Recent research has developed new techniques that can make superoptimization more applicable to general code.

In this talk I will introduce superoptimization and give some examples of the weird and wonderfully short sequences of code it produces. I will introduce the GNU superoptimizer and show how it is used, including some of the recent improvements I have contributed. The final part of my talk will look at the latest research including machine learning and constraint solving, and show how in future superoptimizers may be able to optimize much larger programs.

In this talk I will introduce you to a Docker container that provides you an easy way to do distributed graph processing using Apache Spark GraphX and a Neo4j graph database. You'll learn how to analyze big data graphs that are exported from Neo4j and consequently updated from the results of a Spark GraphX analysis. The types of analysis I will be talking about are PageRank, connected components, triangle counting, and community detection.

Database technologies have evolved to be able to store big data, but are largely inflexible. For complex graph data models stored in a relational database there may be tedious transformations and shuffling around of data to perform large scale analysis.

Fast and scalable analysis of big data has become a critical competitive advantage for companies. There are open source tools like Apache Hadoop and Apache Spark that are providing opportunities for companies to solve these big data problems in a scalable way. Platforms like these have become the foundation of the big data analysis movement.

Gradual typing in dynamic languages is becoming popular. The implementations for Python, Lua, Clojure and Racket show how a dynamic language can be retrofitted with static type checking. This makes possible to combine the flexibility of these languages with the guarantees of a type checker and can be done in a gradual, non-invasive manner.

In this talk we'll understand what gradual typing is and the benefits it yields, explore the existing implementations for Python and talk about Guido's plans for the usage of function annotations introduced in Python 3.

With free software, anyone can inspect the source code for malicious flaws. But Debian provide binary packages to its users. The idea of “deterministic” or “reproducible” builds is to empower anyone to verify that no flaws have been introduced during the build process by reproducing byte-for-byte identical binary packages from a given source.

This talk will explain the current status of the Debian Reproducible Builds project, how this is relevant for the complete free software eco system and how you can contribute.

see https://wiki.debian.org/ReproducibleBuilds and https://reproducible.debian.net

A summary of four years working on pkg:

• why a new packages manager;
• what happened in the different versions;
• mistakes made;
• lesson learned
• What is cooking for the future:
  • within pkg(8) itself;
  • packaging the FreeBSD base system;
  • improvement in the ports tree.

This talk will propose several ideas for inclusion in a set of modern legal standards for good practices in FLOSS development and governance beyond the traditional emphasis on software freedom-conformant source code licensing. The theme will be maximizing diverse, egalitarian and authentically meritocratic participation, minimizing legal impediments, and avoiding distortion or corruption by powerful project stakeholders. Ideas to be discussed include distributed and symmetrical copyright licensing, fair trademark policies, appropriate approaches to patent nonassertion by corporate participants, and commitments by projects or associated foundations to promoting diverse and safe environments for development work.

Ideas discussed in this talk may form the basis for work done by the Open Source Initiative during the coming year.

It was traditionally assumed that licensing of source code under a free software/open source license, with its basic forkability guarantee, was sufficient for software to be free. More recently, some have suggested that source code licensing criteria is insufficient to capture what is truly normative in the development and governance of FLOSS projects, but no settled view on what constitutes "open development" or "good FLOSS governance" has yet emerged.

While some ideas that have been suggested for defining so-called "open development" and good project governance focus on technical criteria, this talk will discuss those that are essentially legal in nature, and the policy justifications for their inclusion. At root these concern the desire to maximize diverse participation on an egalitarian and authentically meritocratic basis with a minimum of legal or other structural impediments, and an avoidance of distorting or corrupting influence by relatively powerful or influential project participants or governance stakeholders.

Important examples of such legal criteria include distributed copyright ownership coupled with symmetrical inbound/outbound licensing, as well as community fairness in trademark policy formulation and the arguable need for external mechanisms of patent nonassertion for projects dominated by corporate contribution. I will also argue that it is an essential legal feature of good governance for projects or their affiliated foundations to affirmatively prevent or police abusive or exclusionary behavior by project participants. Some focus will be placed on problems presented by large-scale, well-known projects that receive significant corporate participation.

A brief overview of Kodi (XBMC) open source Media center. How one of the oldest and largest open source projects originated, the path walked to present day and what the future might hold. Talk will include a brief history overview, what steps were taking to come in current state and what our goals are for the future.

It's relatively rare and difficult to keep a large scale open source project going year after year without the firm financial backing of a larger organization. Since its inception in 2002, the software currently called Kodi has gone through numerous changes, both at the software level and at the organizational level, and has encountered numerous difficulties along the way, from simple communications problems both internally and with the userbase to larger organizational snafus. In this talk, we'll review how the organization has managed to overcome these problems and continue on.

Topics expected to be covered will include a look at the platforms, distributions, and hardware supported today; a review of the history on the Xbox, the switch to platform agnosticism, and the creation of the Foundation; and plans for the future.

Additionally, an overview of how the organization works and software is developed currently will be presented, along with a look at who uses Kodi, both from a user perspective and a business perspective.

Matrix is a new, pragmatic HTTP-based clean-room alternative to XMPP, SIP, IRC and other messaging/VoIP technologies. It consists of an open standard defining RESTful HTTP APIs and open source, Apache-licensed reference implementations for creating and running your own real-time communication infrastructure.

Our hope is to make VoIP/IM as universal and interoperable as email, and build an open ecosystem that people can use for a multitude of purposes.

We believe that real-time communication is fundamentally broken and fragmented on today's internet. XMPP and SIP tried to solve this, but haven't taken off as they might have done, leaving the internet dominated by closed proprietary islands of communication like WhatsApp, Facebook, Hangouts, etc.

Enter Matrix: a set of pragmatic RESTful HTTP JSON APIs as an open standard, intended to be implemented on a wide range of servers, services and clients, letting developers build messaging and VoIP functionality on top of the Matrix ecosystem rather than adding yet another closed/proprietary solution.

In Matrix, every user runs one or more Matrix clients, which connect through to a Matrix "homeserver" which stores all their personal chat history and user account information - much as a mail client connects through to an IMAP/SMTP server. Just like email, you can either run your own Matrix homeserver, which means you own and control your own communications and history - or you can use one hosted by someone else (e.g. matrix.org) - there is no single point of control or mandatory service provider in Matrix. In fact, there is no single point of control over conversations in Matrix at all - conversation history is a first class citizen, with room state replicated over all participating servers, avoiding single-points of failure or control as you get in XMPP MUCs.

In the end, we hope Matrix will crack the problem of a widely successful open federated platform for communication on the internet, and provide a worthy alternative to the PSTN. You should be able to use your favourite app to communicate via Matrix - and your recipients should be able to reply through the app of their choice!

Open Document Format (ODF) is the native file format of LibreOffice. It means that all features of the document model must be represented at the ODF level, too. The features, which cannot be represented in ODF version 1.2, need to be submitted to OASIS to be included in the next version of the standard. My talk gives an overview of recent work and plans of the LibreOffice project related to ODF standardization.

What is cloud management and why do you need it? This talk explains the security and productivity ramifications of a hybrid cloud infrastructure, and how you can wrangle its various components. You need: comprehensive security, finance/chargeback, automation and orchestration. Here's how to control all of the things.

What is "Cloud Management"? In a datacenter, you might have 2 or more virtualization management platforms, with a private cloud running alongside, and some workloads running in a public cloud. ManageIQ gives admins and developers a way to seamlessly deliver services from multiple cloud and virtualization platforms.

Across your cloud and virtualization platforms, you'll need to enforce some kind of consistency in who can consume your resources, integrate with approval workflows, and be aware of waste when it is happening. Maybe you also want to automate the provisioning of instances, integrate with a service catalog or configuration management system. Perhaps you want to know when VMs are vulnerable to security issues, prevent new VMs to be created from known-bad templates, and perform some clean-up of services when they are retired.

These are all cloud management problems. Whether it's containing VM sprawl or finding and fixing hot spots in the data center, this presentation will give you tools and techniques you can use to manage it all.

ManageIQ is a recently open sourced cloud management platform and toolkit with a RESTful API and comprehensive gateway to most popular virtualization and cloud services platforms, including vSphere, Hyper-V, oVirt, RHEV, AWS, and OpenStack (with more on the way). It is a powerful orchestration and automation engine that admins use to integrate their build, test and deploy services with virtualization and cloud platforms. ManageIQ allows developers and admins to manage their services in one place, side-by-side.

In this technical deep dive, we will explore the orchestration and automation components of ManageIQ and demonstrate how it can be used to operationalize any hybrid cloud deployment . You'll learn about:

Code to create an application service catalog.
Automation of compute host evacuation in response to monitoring and security events
Preparation of physical compute hosts in advance of planned maintenance work.
This talk will include an overview of the ManageIQ community as well as a live demonstration.

The Perl programming language is currently enjoying a resurgence in popularity, and for good reason! Perl 5 development continues to move forward with new features being introduced and many old ones improved, meanwhile the development of Perl 6 is making significant progress and has reached a major milestone, the details of which will be announced by Larry Wall at this very conference. For many years now the development of these sister languages have affected and influenced one another in a myriad of ways. Over the last few years I have been working on a design proposal for enhancing and extending the object system of Perl 5 which borrows a number of elements from the Perl 6 object system. In this talk we will explore the various evolutionary stages of that work, as well as discuss the complexities of adding new features to such a mature and well established language like Perl 5. Along the way we will also examine the various meanings of "legacy" in each context and show how it informed the design decisions that were made.

Besides issues of scaling your search, there are very important aspects concerning search-quality that should not be neglected. Search-quality is mainly controlled by analysis and query parsing. I will talk about frequent problems concerning Lucene analysis and I will show on several examples that usually one analyzer (normal form) is not sufficient, even in a mono-lingual environment but especially in multilingual environments. I will show how our typed index approach allows to solve many of these problems and how we plan to properly treat even mixed-language documents based on this approach.

If you want to search in a multilingual environment with high-quality language-specific word-normalization you soon realize, that you need different types of terms. For example you cannot use morphologically normalized terms or stemmed terms for every kind of search. For Wildcard- and Fuzzy-Search you need terms that have not been normalized at all or that have been normalized only slightly. Phonetic search adds another kind of normal form. Sometimes search should be case-sensitive (e.g. if you want to distinguish between search for the company "MAN" and the word "man") sometimes it shouldn´t. Semantic search (search for persons, organizations and places) might add another type of terms. Usually one uses different fields to distinguish between different types of terms. I will show that putting different types of terms into the same field and representing their type by e.g. a prefix, has an important advantages. It allows you to use the important information about their relative positions. I even challenge the standard approach of having different fields for different languages because it requires so much configuration effort and because it prevents a reasonable treatment of mixed-language documents. At IntraFind we decided to implement a language chunker based on Ted Dunnings paper "Statistical Identification of Language" and to include it into our next-generation linguistic analyzer for Lucene/Solr/Elasticsearch. It identifies chunks of the same language within text and delegates the analysis to a specified language-specific analyzer, which might be a high-quality IntraFind morphological analyzer, a third-party analyzer or one of the high-quality Lucene Open-Source analyzers e.g. for Chinese and Japanese. Terms of different languages are distinguished by different prefixes (types). In this way we can provide an easy-to-use and very powerful linguistic analyzer that requires almost no configuration effort. You simply index your content and don’t have to care about the language. If there is enough time I would like to add a deep dive into Lucene Analysis with position increments and position length and why this is important e.g. for analyzers that decompose terms such as Lucenes WorldDelimiter Analyzer and IntraFinds German Analyzer which also does word decomposition.

Building a medical device requires to follow certain rules specially when health care depend on it. The presentation will explain how Yocto help us in Kaptalia to solve this issue. In particular we will focus on fast boot, update with unskilled user base, Bluetooth Low Energy, security and data privacy.

During this event we will show how our team succeeded to build our first OS, start from a company with medical expert only and no prior expertise on embedded systems.

In addition, an explanation to the Yocto (errors you do not want to repeat) path will be presented.

During a medical procedure, especially when the patient is asleep, the anesthetist need a device to check the vital signs of his patient. As our device is aimed to be used as medical user base, it meets the requirements of being reliable, easy to use, easy to update, and satisfies regulatory environments. Our monitor communicates with some wireless devices using Bluetooth Low Energy. The device contains medical data so we had deal with data privacy and security. During industrialization, the entire OS is deployed in one shot. This operation has to be performed by a technician in a very secure manner. Also, the steps of building our devices will be presented. This includes the device architecture, the fast boot on ARM, the time duration of boot on ARM and its optimization, the bullet proof update, and the custom Bluetooth Low Energie program.

At the end, a live demonstration for using the the monitor and sensor will be held.

Questions & answers

This year the JFree project (that’s JFreeChart and friends) turns 15! Though looking forward not backward is the JFree way, so this session will cover a couple of the latest free things we’ve been working on. We fly high above the low level virtual machine technology, even above the standard Java APIs, so if you want to soar with eagles (and your brain hurts from some other talks about complex low-level magic) then come a see some shiny graphical things and we’ll promise not to talk about anything that’s complicated!

In this session, you will hear about our recent JavaFX work, or get a quick demo of JFreeSVG, or maybe we’ll surprise you with something else graphical, awesome and free. :-)

As Python programmers we're used to program without taking care about allocating memory for our objects and later on freeing them, Python garbage collector takes care of this task automatically for us.

Garbage collection is one of the most challenging topics in computer science, there are a lot of research around the topic and different ways to tackle the problem.

Knowing how our language does this process give us a better understanding of underlying interpreter and allow us to know why problems like cycles can happen in CPython interpreters.

So, this talk aims to be and introduction to the topic and a walkaround through different approaches followed in CPython and PyPy:

• Generational Reference counting with cycles detector on CPython.
• Incremental version of the MiniMark GC on PyPy.

As Python programmers we're used to program without taking care about allocating memory for our objects and later on freeing them, Python garbage collector takes care of this task automatically for us.

Garbage collection is one of the most challenging topics in computer science, there are a lot of research around the topic and different ways to tackle the problem.

Knowing how our language does this process give us a better understanding of underlying interpreter and allow us to know why problems like cycles can happen in CPython interpreters.

So, this talk aims to be and introduction to the topic and a walkaround through different approaches followed in CPython and PyPy:

• Generational Reference counting with cycles detector on CPython.
• Incremental version of the MiniMark GC on PyPy.

Imagine buying off the shelf switch hardware, install Fedora (or any other distribution) and configure it using standard linux tools. This is not possible at the moment primarily because of lack of unified and consistent platforms and driver interfaces. We are working to change that.

The current state of support for switch chips in Linux is not good. Each vendor provides userspace binary sdk blob that only works with their chips. Each of this blobs has proprietary APIs. To get switch chips properly supported there's need to introduce a new infrastructure directly into Linux kernel and to work with vendors to adopt it.

This talk presents the current effort to unify and uphold the Linux networking model across the spectrum of devices which is necessary to make Linux the cornerstone of industrial grade networking. The scope of this talk covers state of art with current implementation of standard commodity switches such as top of rack switches, small home gateway device as well as SR-IOV NIC embedded switches.

A device model and driver infrastructure will be presented for accelerating the Linux bridge, Linux router, accelerated host virtual switches and flow level offloads when supported by the hardware underneath.

Homebrew is a popular package manager for OSX. We have a relatively unusual contribution and maintenance model and some practices that differentiate us from other package management systems on both OSX and on Linux. This talk will discuss some of the lessons learnt from maintaining Homebrew to facilitate discussion of how we and other package managers can do better.

The audience for this talk is primarily developers of other package managers and maintainers of Unix distributions. We all do things in slightly different ways so this talk aims to facilitate discussion of what we can do better and how we can work together to minimise repeated work. Audience members will learn about Homebrew, how to encourage more contributions to package managers and how to handle a large number of packages will very few maintainers and time spent.

The plan would be a 15m somewhat interactive talk with 15m discussion afterwards.

RubyMotion is a toolchain that lets Ruby developers write iOS and Android apps. Internally RubyMotion features 2 distinct implementations of the Ruby language (one for the Objective-C runtime and one for the JVM) as well as a static compiler written with LLVM. In this presentation, we will dig inside RubyMotion and see how everything works, from unified runtimes to static and dynamic (JIT) compilation strategies.

This presentation will focus on RubyMotion internals. It will not cover iOS or Android development. It will not focus on Ruby as a development language as well.

We will start by introducing RubyMotion then explain how it works. We will do quick overviews of the 2 Ruby runtimes included in RubyMotion, which are full implementations of Ruby, and explain design and implementation decisions.

Following up, we will explain how RubyMotion apps are statically compiled into machine code. We will have a look inside the RubyMotion compiler, written in LLVM, and we will explain how a dynamic language such as Ruby gets compiled statically. We will look at a few optimization passes.

Finally, if we have time, we will show up a few exciting use cases of the LLVM JIT, used to implement the REPL (irb) in RubyMotion.

Corinthia is a brand new apache project, based on the very successfull UXwrite editor. Peter Kelly decided earlier this year to make his editor open source (Thanks), and we rapidly built a community around it. Corinthia is firstly a toolkit for document format conversion, that ffacilitates round trip conversion without data loss. The engine us a complete new idea comming from desktop editors like LO and AOO. The idea of the editor is not to replace a full fledged desktop editor, but merely to let you correct minor things when you discuss your work with friends wich of course happens on a tablet.

The corinthia project is a new apache project, and while we look at lot at LO and AOO we look for new ideas.....actually some of the LO/AOO developers told us to start fresh......here we are, cone listen to what we are and will do.....one person named us AOO light, for sure that is not who we are, but we would love to have discussions and participation with the people if both LO and AOO.

The presentation will show where we are and where we would like to be.....but honestly a big debate is hoped for, and stay sure, some remarks will be made to provoke a debate.

The preseneter is a commiitter in AOO (former PMC) and a STRONG believer in cooperation.

Yjs is an open source framework that can be used to collaborate in real-time on arbitrary data types. It is based on a new operational transformation-like approach that can be used in peer-to-peer settings on the Web, using standard communication protocols such as WebRTC or XMPP. Part of the shared editing projects family (e.g. ShareJs, OpenCoweb, etc.), Yjs currently implements support for text, XML and JSON and proved to be very fast and reliable. In this lightning talk we introduce the concepts and features of the Yjs framework and discuss how it can be leveraged to design the next generation of peer-to-peer shared editing tools. We conclude the talk with a short demo that highlights the capabilities of the framework.

Yjs solves many of the current issues for concurrency control and consistency maintenance approaches in collaborative software. In order to achieve this, we created a new approach for optimistic concurrency control, which was formally proven to be reliable and to output the best time complexity (compared to existing dedicated related literature). The approach was designed to support real-time shared editing on linear, tree and graph data structures. A short part of this lightning talk aims to present the core concepts of our approach.

Designed to work on both peer-to-peer and client-server architectures, Yjs can be easily embedded in Web applications in order to foster collaboration. Developed in Javascript, the framework outputs very good scaling capabilities in the number of users and operations in test environments. Yjs currently supports text, JSON and XML data types and was tested using WebRTC and XMPP as an underlying communication protocol.

In this lightning talk, the Yjs framework will be presented to the wider OS community for the first time. We consider our framework to be developer friendly, but given the opportunity of a lightning talk, we would like to invite FOSDEM developers to use Yjs and share with us their experience. Ideally we aim to establish connections and potential collaborations, in order to improve our open source project.

Determining what codecs, containers, and specifications should be favored in audiovisual preservation and how to use them is an ongoing dialogue within archives. Media preservation is a relatively small community and thus often relies on technology and recommendations from larger related communities such as broadcast, media production, and increasingly open source development to support the objectives of audiovisual preservation. As the machinery and skills needed to sustain access to film and analog video collections decay it is increasingly urgent for archives to address blocking technological issues in order to re-format legacy audiovisual recordings to digital formats efficiently. This presentation reviews the requirements and demands on technology within audiovisual preservation projects and assesses the opportunities for existing open source technology to contribute to resolving preservation challenges. The presentation will focus on lossless audiovisual codecs, technical and contextual metadata, and both the openness and standardization of relevant file formats.

Our question was: "what is the best infrastructure to run our SaaS on?". We tried most of the infrastructure software, starting from vmware, moving to Proxmox, OpenNebula, OpenStack, and Google's Ganeti. We also considered software storage and software defined networks. We mastered some of these technologies and we even contributed to the projects. But we felt we needed something different and lighter and we "blended" our own solution, mixing and matching the best of the above and keeping in consideration our needs in terms of computing, network and storage. This talk will go through our (long) journey, understanding pros and cons of each technology and describing what we used to deliver SecurePass and other services.

Infrastructure and configuration are now being represented as code. This code is then put into git repositories, OSI approved licenses are attached, and the code published. This creates an Open Source project. There are several instances of this now: OpenStack, Mozilla, Wikimedia, and Jenkins all have open sourced their infrastructure. It is, however, relatively easy to say "our configuration is totally open source, anyone can use it", and it is actually much harder to actively consume someone else's configuration. My team consumes one of these open source configuration projects and sits downstream from it. I will present on we're doing, what has worked, what hasn't, and what we're going to do next. I'm going to give actionable advice for people who are consuming or want to be consuming another organization's open source infrastructure, and I'll be providing some feedback to those who are currently open sourcing their infrastructure on how to make it easier to consume.

OpenStack's infrastructure team has an open source infrastructure primarily using the Puppet configuration management tool. Using hiera they are able to separate secrets from puppet code, and using roles they can keep OpenStack specific logic from generically reusable configuration. The infrastructure is multifaceted but the core of it is gerrit for code review, cgit for code checkout, zuul for merging/gating, jenkins and gearman for testing with apache, mysql, and zmq doing what they do best.

My team at HP consumes this open source infrastructure and replicates it internally. We use their Puppet code, and do the dance of the downstream: patch/submit patch upstream/reconsume patch after it has landed upstream. We call the project Gozer and our admins are called Ghostbusters. We attend the weekly meeting that upstream holds, and some of us are well on our way to having our upstream commit bits, but our core focus is on maintaining the downstream ci/cd pipeline for HP. Configuration management is the reason any of this is possible. I'm going to talk about specific ways Puppet code can be written to be re-consumable, and highlight a couple 'dead ends' we walked down before finding some successful patterns.

In this presentation I will cover:

The problems upstream is solving, the problems downstream is solving, where those goals align and where they differ

How we bootstrapped our infrastructure(and why that was a problem)

How we participate upstream

How the Puppet codebase has evolved to be more consumable, where it started, and where it is now

How we dealt with different network topology between our infrastructure and upstream's infrastructure

How we maintain parity with upstream (consistently consuming it)

How we consume data, not just code

Answer questions

The purpose of the WebFX project is to investigate the capabilities of using JavaFX to build rich web applications. Actually, it is an attempt to create a new web where HTML is replaced with FXML — the markup language for JavaFX UI, and the logic can be written in any programming language that is available on top of Java platform from JavaScript, Groovy, JRuby to Java, Kotlin and Scala. Java ReStart is a complimentary project that acts as transport layer for WebFX allowing FXML pages to reference arbitrary Java byte code on a web server and hence any custom JavaFX UI components and Java third-party libraries. In addition, Java ReStart allows to run arbitrary Java applications instantly from a web server downloading only required parts of applications on demand and executing them in parallel with downloading.

I would like to give an overview of the projects, make a live demo, compare the proposed technologies with traditional web and native clients, show how the technologies differ from Java applets and Java Webstart, reveal benefits in compare with RDP-like approaches. Finally, I will share my vision on how to evolve the projects.

The huge increase in software patent litigation over the last 15 years has produced reams of articles, cost fortunes and even snagged the US President's attention. But when something goes on for long enough, it also produces data -- lots and lots of data. So what have we learned from all the data?

The huge increase in software patent litigation over the last 15 years has produced reams of articles, cost fortunes and even snagged the US President's attention. But when something goes on for long enough, it also produces data -- lots and lots of data. So what have we learned from all the data?

Non-practicing entities are growing and litigation costs increase each year, but that's hardly the whole story. Even as defensive strategies are proliferating, software patent plaintiffs are becoming much more sophisticated. Software patent trolls are expanding their reach internationally and practicing entities are increasingly embracing troll-like behavior. Ms. Nicholson will examine data from academic and industrial sources to see what it all means for Linux, Android, GNU and the rest of the free software community. More data provides more opportunities to defend free software from the pernicious effects of vague and overly broad software patent aggression, as long as we are willing to use it.

Cairo is a 2D graphics library with support for multiple output devices. It is designed to produce consistent output on all output media while taking advantage of display hardware acceleration when available. The Cairo API provides operations similar to the drawing operators of PostScript and PDF. Operations in Cairo including stroking and filling cubic Bézier splines, transforming and compositing translucent images, and antialiased text rendering. All drawing operations can be transformed by any affine transformation (scale, rotation, shear, etc.).

Illustrated by a poker game application, this presentation will show you how to do nice drawings with Cairo, still programming with your preferred language: Ada!

Graph Databases are naturally well-suited for building recommendation engines. In this talk, Michal will share his experience building a number of high-performance production-ready recommendation engines using Neo4j and introduce the open-source GraphAware Recommendation Engine Library, which enables Java developers to rapidly build their own recommender systems.

This presentation starts by a brief explanation of why graphs are a suitable data model for building recommender systems. A summary of typical recommendation engine requirements follows, including the business and technical challenges these requirements introduce. Afterwards, the talk dives into possible solutions of these challenges, both from business and architectural/design perspectives, and introduces the GraphAware Recommendation Engine Library.

What follows is a demonstration of how this open-source recommendation engine skeleton solves many of the issues and how it handles the "plumbing", so that developers can focus on expressing the business logic specific to their domain.

The talk concludes by presenting complexities yet to be solved, and a brief survey of alternative approaches.

A majority of examples in this talk are drawn from real-world use cases and the speaker's personal experience building recommendation engines. Attendees should have a very basic understanding of graph theory. Prior experience with Neo4j and the Cypher query language is a plus, but not necessary. Ability to read Java is recommended.

Attendees will learn: * what is a recommendation engine and what it is good for * why graphs are a good fit for building one * what business and technical challenges one faces building a recommender * what possible solutions there are for these challenges * how to build a high-performance graph-based recommendation engine in minutes * real-world case studies

Writing code that modifies source code is a task reserved to a small number of audacious developers. RedBaron was built on the foundations of a Lossless Abstract Syntaxe Tree (AST) and serves to make customized refactoring accessible to as many developers as possible. It does so by offering an abstraction that allows to focus on specific objectives regardless of the low-level details.

RedBaron's aim is to make the process of writing of code that modifies source code easy (and fun) enough to change it into a manageable, or even desirable, task. To do so, RedBaron acts like BeautifulSoup/JQuery onto your Python source code. The idea is to make it powerful and expressive enough so that it can be directly used into a Python shell like IPython.

Baron, the basis for RedBaron , is a Syntax Tree for Python meant to preserve every information. In this way, [source code -> tree -> source code] will yield the exact same source code even at the formatting level. Baron is relatively stable; it comprises over 1000 unit tests; it was applied to the top 100 pypi packages; and it is documented. Though still in development, RedBaron is stable and functional. The next step consists in making it enjoyable to use. Around November it comprised more than 1200 unit tests, and was fully documented with numerous examples.

Source code and documentation:

• RedBaron: https://github.com/psycojoker/redbaron http://redbaron.rtfd.org
• Baron: https://github.com/psycojoker/baron http://baron.rtfd.org

The ambitious aim of RedBaron is to facilitate the writing of code-writing source code and make this task both realistic and enjoyable.

LAVA is a python service created by Linaro for testing software on hardware which accepts test jobs to perform on selected hardware to provide a black box to continuous integration tests. Bisecting is a technique for finding commit in version control system that broke the software. Git provides the powerful "git bisect" subcommand for this purposes. In this talk we give and introduction to LAVA and explain howto combine LAVA and git bisect to automatically find offending commits in the Linux kernel.

LAVA stands for "The Linaro Automated Validation Architecture", A tool created to help automatic testing of ARM Linux systems. It is completely open source and developed out in open. LAVA is the testing side of the Linaro's continous integration loop, providing users ability to do smoke, regression and performance test easily on wide variety of ARM boards. It provides a web dashboard for submitting test jobs, viewing results, trends and states of users jobs. Pretty much any embedded Linux project involves updating the kernel and booting the target board numerous times. LAVA helps take away the manuals steps from the process.

"Git bisect" is a powerful command in git. It lets users do a binary search from git version history between a "known good" and "known bad" commit to find which exact commit is at the fault on regressions. Most developers who actively use git are familiar with bisect, those who are not, should definitely consider learning it.

Wiring up LAVA to manual bisect testing is easy, but why settle there, when you can automate it all the way? During the presentation we let the computer do a bisecting demo in background.

Knot DNS is a high-performance authoritative-only modern open-source DNS server. In this talk Knot DNS will be presented we will present the motivation, the goals and the current state of the project.

The Knot DNS supports most of the DNS standards and it has been already deployed at several TLDs and DNS hosters. Deployment at two root servers are already planned in upcoming months as an alternative to Bind 9 and NSD. The goal of the presentation is to show the audience the alternative DNS server that can be used to increase code diversity of used DNS software on the Internet.

Come and hear about what we had to do to get LibreOffice on the Android platform - how we stripped down Fennec (Firefox for Android), combined it with the LibreOfficeKit, and still got an .apk that fits the 50M limit of the Play store.

Introduction to OP^2 Project, which provides a framework for implementing SIP hardware phones.

Project OP^2 started as a self-learning experience to see if the features present in SIP desktop clients could be brought to a hardware device. Traditional VoIP hardware phones are very closed systems, and Project OP^2 was designed with openness and flexibility in mind. The first prototypes were built using a RaspberryPi as the hardware platform.

Performance Co-Pilot is a highly adaptable and established toolkit for those interested in examining the details of system performance. Similarly, Systemtap is a powerful tool for digging deep into the innards of a program. This presentation will go over the basics of the tools, recent developments, and examples.

Performance Co-Pilot is a highly adaptable and established toolkit for those interested in examining the details of system performance. When used in tandem with Systemtap, an introspection tool, both developers and system administrators are able to progress from a high level view of the current performance, to detailed information about a specific subsystem or program. This presentation will go over the basics of the tools, recent developments, and examples.

OpenGL is an API for rendering 2D and 3D graphics now managed by the non-profit technology consortium Khronos Group. Implementors are free to provide their own implementation of the API. For example, in GNU/Linux systems NVIDIA provides its own proprietary version while other manufacturers like Intel are using Mesa, the most popular open source OpenGL implementation.

Because of this implementation freedom, ensuring compliance with the specification is important. Khronos provides their own OpenGL conformance test suite but there are several unofficial open source alternatives.

This talk will explain some of these open source OpenGL conformance test suites and give an introduction about how to use them, including sharing tips between the speaker and the audience.

Domain Specific Languages, defined broadly, are everywhere. We will look at the good, the bad and the ugly and see where Lisp excels (ranting a bit about Configuration Management tools as that's what I spend lots of my day doing)

The world is buzzing with the idea of teaching everyone to program. Sometimes we create simpler languages and environments for learning but if we constrain them too much we can impoverish the learner.

For scientists we have R, Maple, Mathematica and Matlab etc - but how easy is it to build a web service, run Hadoop jobs, read files in some obscure format or talk to a datastore? Better to give them a productive environment to solve their problems quickly, with the full power of Clojure when they need.

Concretely we will reimagine Netlogo and Geomlab as Clojure DSLs. See how embedding them in Clojure makes the implementation easier, gives greater power to the user and enables extension.

We have a bunch of great embeddings already in Clojure: logic, stats, datalog, CSP - Let’s build more and not trap people in DSL Hell.

This talk will discuss the practical ways that someone who is wanting to grop either a community or a meetup around their project or distro they use. Aimed for developers who might be more into the back end side of things, this talk will attempt to show people ways that are both often overlooked and easy to implement for the both the average user and the experienced developer.

Have you ever wanted to grow your projects community, both at home or on a global scale? This talk will go in depth about the problems most people face when they attempt to grow a users group and discuss the areas that people can easily work on to make their users group, or even community as a whole, be a thriving member of the free software world. If you have thought that running meetups is too much work, and afraid to try, this talk will show how meetings and gatherings can plan themselves, and ultimately become the best way to grow your projects community. I will mainly focus on the Ubuntu users groups I have run in the past and still run today. This will be the place where most of my examples come from and where my information will be from.

Most of us already owe Prolog a debt indirectly via Erlang. However, logic programming in and of itself has much to teach us about approaches to systems - taking declarative system descriptions to a new level of abstraction, and finding ways to integrate these ideas back into more common workflows. From Prolog to Erlang to Haskell to Lisp to TLC and then back to Prolog I have journeyed, and I'd like to share some of the beautiful and brilliant things I've discovered along the way and why I think they might make us better operations geeks. And when approaching new languages, always remember: You can't scare us, we've used m4.

Kaltura is widely used to address a wide range of education, media, and enterprise video needs. In this talk covers how Kaltura interact with open source components for an end to end scalable FOSS video platform. We also cover how the core open source Kaltura platform interacts with these components, giving best practices for your own online video projects weather using a single component or integrating with a larger platform.

In addition to contributing its core server as an open source video platform offering, Kaltura makes use of many third party FOSS projects. This session will walk attendees through major projects used by the Kaltura platform to ingest, analyze, optimize, record and play video files, and provide guidance in optimizing use

The following projects and their role in our architecture will be surveyed:

• Kaltura server -- Pulls together all the media services under a unified REST API.
• nginx-vod-module - An Kaltura developed Nginx module for On-the-fly repackaging of MP4 files to DASH, HDS, HLS, MSS
• Mediainfo - used to analyze source videos to determine how best to handle them
• FFMPEG and Mencoder - used in transcoding to optimize source videos so that they'll be best viewed by various devices; i.e: Desktops, tablets and cellphones running different OSes
• ImageMagic - used for image manipulation and thumbnail creation
• Red5 - used in order to record from webcams, and broadcast live streams.
• The Kaltura HTML5 player - used for playback in native and web environments.

The session will include a review of our video source detection and optimization processes as well as demos showing how each project is used within the platform.

We will conclude with an overview of our current community activities and focus.

The document manager will bridge the Android port of LibreOffice with the services provided by this operating system. We will show the current status, specially regarding the implementation of the cloud storage support funded by The Document Foundation, and present a vision of the future of this component as a full featured, Android-centric document manager.

Designate is a newly incubated project in OpenStack, for providing an easy to use, integrated DNS service to users of your cloud. We integrate with Nova and Neutron, and allow control of Reverse DNS for floating IPs. Using sink features, we can pull events from the neutron / nova event queue and auto generate DNS entries.

We will show all of this functionality, and talk about the upcoming features, while taking feedback from the community about what else they would like to see provided by Designate.

We will also update the community on the developments of the Mid-Cycle summit (happening the week previously)

Graham Hayes is a member of designate-core, and one of the main architects of our current feature push called server pools, which will allow per user DNS servers, and the ability to run DNS servers at massive scale.

Kiall Mac Innes is the PTL and the original author for Designate

Key/Value stores rely on a simple data model represented by a map, where each key appears once. Using such a structure does not necessarily mean giving up on query expressiveness and capability. This talk will demonstrate what Infinispan can do to empower your analytics needs, from directly running Lucene Queries in a cluster to Hadoop Map Reduce and Spark.

Arduino is the favorite programming platform for embedded hardware, especially for beginners, but also for more advanced users who take advantage of its ease of use. We will show how to program more effectively, easily, and in collaboration with others. By using codebender, you can code, compile, and test Arduino code online, take advantage of the ~500 included libraries, and use code available by the community.

We will show how someone can use Arduino with the power of codebender.

Python is a great language, but there are occasions where we need access to low level operations or connect with some database driver written in C or we need to overcome to some speed boottleneck in Python due to some limitation in the language, like NumPy or Scikit-learn do, using extensions.

With the FFI(Foreign function interface) we can connect Python with other languages like C, C++ and even Rust or Fortran. There are some alternatives to achieve this goal, Native Extensions, Ctypes and CFFI. We'll compare this three ways of extending Python and we'll study pros and cons of each approach.

Python is a great language, but there are occasions where we need access to low level operations or connect with some database driver written in C or we need to overcome to some speed boottleneck in Python due to some limitation in the language, like NumPy or Scikit-learn do, using extensions.

With the FFI(Foreign function interface) we can connect Python with other languages like C, C++ and even Rust or Fortran. There are some alternatives to achieve this goal, Native Extensions, Ctypes and CFFI. We'll compare this three ways of extending Python and we'll study pros and cons of each approach.

Since the late 1980s, the discipline of network management has kept up well enough with virtual notions in networks while continuing to rely heavily on the Simple Network Management Protocol (SNMP). The rise of software-defined networks poses similar challenges to the ones brought to the systems management space by server virtualization and cloud computing, leaving practitioners to wonder how much retooling will be needed to cope in this new world.

As the oldest enterprise-grade, open-source network management platform, OpenNMS has proved fairly adaptable so far. This talk will cover where we've been, what's possible given today's realities, and what we expect will be the toughest challenges in the future.

The Tesseract is a distributed graph processing and computation platform, purpose built, from the ground up. This talk will present the new algorithms developed to create an efficient platform for native distributed graph traversals and computations.

The last 10 years has had provable uses of graph processing systems. As we aim to do more, we stretch existing technologies far beyond what they were intended for. Remarkable efforts like Apache Giraph or the Titan project are examples that are pushing the bounds. Ultimately the brute force techniques are inefficient, often don't scale very well and come with their own problems. In the ideal world, a scalable graph processing system would evenly distribute both vertices and edges. Richard Karp has shown this to be an np-complete problem (i.e. the clique problem / complete subgraphs).

The talk will give a brief introduction to CRDT - Convergent & Commutative Replicated Data types and how commutative & idempotent operations enable the three contributions. Three key contributions The Tesseract makes include partitioning "super vertices" with a technique called "cascading vertices", an optimization called "wormhole traversal" and a computational framework, "TQL" able to make use of two aforementioned techniques. The talk will give an introduction to the first two and a very brief overview of the third.

Typically, GPL enforcement activity involves copyright infringement actions which compel license violators to correct errors in their GPL compliance,thus yielding the policy goals of the GPL: the rights of developers and users to copy, share, modify and redistribute.

While traditional enforcement is often undeniably necessary for embedded electronics products, novel approaches to GPL violations are often possible and even recommended for more traditional software distributions.

Recently, Conservancy engaged in an enforcement action whereby,rather than fight the violator in court, Conservancy instead fostered and provide resources and assistance to a vetted GPL-compliant fork of a violating codebase.

This talk discusses which scenarios make this remedy optimal and lessons learned. The talk includes some licensing and technical content about vetting licensing information of codebases.

Peer5 is a content delivery network based on WebRTC, a widely adopted open source project. The talk will be about how we deliver media using a hybrid system of HTTP and peer-to-peer mesh network.

We will review the API which is agnostic to the video technology, and show how it works with MP4, HLS, DASH and open source video players.

We will also cover the advantages of being heavily based on open source projects and how it is compared to client based proprietary solutions in terms of security, portability and more.

This talk aims to give an overview of the introduction of the ODF standard and Apache OpenOffice in an Italian public administration with more than 3000 users, addressing briefly the main technical issues and solutions. In particular we will talk about: 1) the configuration of OpenOffice, extended with community developed and custom extensions to help users in the everyday work 2) the interoperability with Sharepoint through the webdav protocol and what we developed in Apache OpenOffice for the correct interaction 3) our extension to simplify picking the right format for file exchange, to answer the users' ubiquitous question "Ok but… should I use ODF to send/share this?”, in relation to our ODF census project in Italy.

I present Rizzly, a programming language and compiler I am working on. It is designed for the event driven programming of the smallest 8 bit micro controllers.

In this talk I first present the concepts and some interesting details of Rizzly. Although one can already use Rizzly, there are several open tasks. In the second part I will address those and present ideas how to solve those.

We've been talking about Infrastructure providers for quite a bit already. OpenStack itself started as such an IaaS and then it quickly became a cloud provider. But what does that mean? What is a cloud provider suppose to provide? What's cloud after all?

Scaling a distributed system goes beyond virtualization, shared storage etc. In order to support on-demand scaling it is necessary to have an easy way to provision and consume the available infrastructure, a way for the services running in it to communicate, etc. Not to mention latency needs, reliability, etc.

This talk aims to answer the above questions and take a step further down the path of explaining what should be considered essential for nowadays needs, especially when those needs require a cloud to be covered.

We've been talking about Infrastructure providers for quite a bit already. OpenStack itself started as such an IaaS and then it quickly became a cloud provider. But what does that mean? What is a cloud provider suppose to provide? What's cloud after all?

Scaling a distributed system goes beyond virtualization, shared storage etc. In order to support on-demand scaling it is necessary to have an easy way to provision and consume the available infrastructure, a way for the services running in it to communicate, etc. Not to mention latency needs, reliability, etc.

This talk aims to answer the above questions and take a step further down the path of explaining what should be considered essential for nowadays needs, especially when those needs require a cloud to be covered.

Graphgen aims at helping people prototyping a graph database, by providing a visual tool that ease the generation of nodes and relationships with a Cypher DSL.

Many people struggle with not only creating a good graph model of their domain but also with creating sensible example data to test hypotheses or use-cases.

Graphgen aims at helping people with no time but a good enough understanding of their domain model, by providing a visual dsl for data model generation which borrows heavily on Neo4j Cypher graph query language.

The ascii art allows even non-technical users to write and read model descriptions/configurations as concise as plain english but formal enough to be parseable. The underlying generator combines the DSL inputs (structure, cardinalities and amount-ranges) and combines them with a comprehensive fake data generation library to create real-world-like datasets of medium/arbitrary size and complexity.

The genrated data can be visualized, directly imported into a remote Neo4j database or exported in a variety of formats.

Users can create their own models combining the basic building blocks of the dsl and share their data-descriptions with others with a simple link.

Discussion panel with the IaaS/Virt devroom organizers about the day's program.

Discussion panel with the IaaS/Virt devroom organizers about the day's program.

Virtual Worlds Research has been using Ada to build large scale economic simulations for 10 years now. These simulations have been used by Governments and others to model the effects of, amongst other things, changing Legal Aid and reforming Social Care funding - many billions of pounds of annual spending. Here, I discuss our experiences, good and bad, with the Ada language, and provide a live demonstration of the most recent model. I'll also discuss work in progress to build a new forecasting model in association with the University of Southampton.

Prospero Technologies has made a Linux based Digital Video Recorder which constantly records all UK broadcast TV so that the consumer no longer needs to schedule recordings. This will be a talk on the technologies used to achieve this, the open source software on the consumer device and how you can build your own 30 channel DVR.

The 30 channel DVR is a consumer version of a product we have been refining, a multi-tuner PCI card called Vortex. I shall be detailing the process and the pitfalls of developing a Linux PCI driver and explaining how Vortex itself works.

Lots of consumer embedded devices run Linux these days, but it's hard to pick out a distribution. I'll be explaining the process we went through, how we ended up with using Yocto for our device and a brief overview of how to roll your own distribution using Yocto.

The final version of the DVR uses a freescale i.mx6 cpu with a video processing unit, the talk will cover how well this is supported by gstreamer and how we built a QT application to display our HTML5 interface.

Python has a great versatile ecosystem but the competition is getting better, this talk is about how can Python keep up with these new languages and where PyPy fits into this.

Recently we've seen the rise of new technologies like Go, Node.js and Julia, those have the ability to build an ecosystem on a clean slate and thus be better than Python in some aspects. What would it take to be as good as those technologies on those aspects without loosing all the things we love about Python ? This talk will describe my perfect future where Python keeps getting better, gets to keep it's great set of libraries and where PyPy fits in that future.

Lightning Talks

The OpenStack Infrastructure team manages a fully open source infrastructure which includes a continuous integration system, as well as tools OpenStack developers around the world use on a day to day basis. This includes the OpenStack wiki, IRC bots, Etherpad, ELK stack and more.

This talk will explain how we've open sourced all of our configuration with Puppet and challenges faced by both our team and downstream consumers of our infrastructure.

A brief introduction to networkd and an update on recent features

systemd-networkd is the network management stack that comes with systemd. In this talk I'll introduce the basic concepts, and outline where we are headed next. I will also discuss the possibility of code-reuse and colaboration with similar projects (in particular ConnMan and NetworkManager), how we have done this so far, and how we plan to do it going forward.

Debugging Java applications is comfortable and simple, but if you want to look beyond the Java horizon, you need special knowledge and and different tools.

This interactive session shows you how to debug a running VM or analyze a VM core file with a native debugger like gdb. You will also learn how to use some of the more than 1,200 VM options to trace or modify the VM behavior. This knowledge can greatly help you identify, isolate and reproduce the root cause of hard VM crashes, and it can also be pure fun to see which actual machine instruction the CPU is executing for your Java code.

In 2009 three Swedish engineers invented a small quadcopter that started with a simple idea: get an electronic board (PCB) to fly. They created the "Crazyflie Nano Quadcopter" which weighs only 19g and fits in the palm of your hand. It can be controlled from various devices, including PC, Android or iOS devices, Raspberry Pi or a R/C remote. While the main client has been written in Python, it has also been ported to Java, C, JavaScript. Since the beginning of 2013 the hardware can be bought from http://www.seeedstudio.com, but the schematics for the PCB and the firmware/host source code are also available on their website/Github account. Due to the low cost for the hardware and the open source approach, the Crazyflie has been used in different private and academic science and research projects around the world.

Why Salomon Automation GmbH has need for Gentoo Prefix. How to provide an LTS distro based on Gentoo Prefix.

In this lecture, after telling about why Salomon Automation GmbH needs something like Gentoo Prefix, and a short overview of the differences between Gentoo Linux and Gentoo Prefix, I'll show how we manage to combine the rolling distribution concept of Gentoo with the Long-Term Support concept.

Elasticsearch, together with his cousins Logstash and Kibana, provide you with a great environment to analyse your data. In this talk we’re going to get inside the eclipse project, analysing what going on, their bugs, etc. If you were wondering what can ELK do for you, this is your talk.

By ingesting the some parts of the source code, plus the bugzilla repos into elasticsearch we’re able to analyse how the project is performing, getting insides on the project evolution during time. The purpose of this talk is to have a real demo on how to process, store and query data using Elasticsearch and friends, if you always had not much time, after that talk you will be able to start analysing your data.

Is Perl 6 dynamic? Well, it sure looks like it: you can eval code at runtime, do all kinds of late-bound lookups, write code without a type declaration in sight, dynamically generate types, and even mutate the language and the way its object model works. But hang on a moment! Misspell a variable or object attribute? That's a compile time error. Call a subroutine that doesn't exist? Yup, same deal. Passing just one argument to a sub that needs two? There's a good chance you'll be told about that too...at compile time. Want to write code that uses native integers and floating point numbers? Go right ahead and throw in some types. Oh, and those super-dynamic modules that extend the language? They can get in on the act, and flag up things to the programmer at compile time too! In this session, we'll explore how Perl 6 strikes a balance between static and dynamic, how the Rakudo Perl 6 compiler takes advantage of this careful design work, and how the language and implementation are flexible enough to let the programmer pick their own trade-offs if the defaults don't fit their problem.

Wrap-up and conclusion of the Open Media devroom, next activities.

Wrap-up and conclusion of the Open Media devroom, next activities.

The Open Media devroom is a new at FOSDEM and co-organised by the European Broadcasting Union and FOMS. It addresses the topics as found in broadcast(radio/TV) and Web media technologies such as video/audio encoding, playout, streaming, broadcasting, metadata . Information of related activities to this topic.

Being able to build the kernel with clang opens up the possibility of using a range of llvm related tools with the kernel code. This talk will introduce a number of the possibilities.

Termination provisions are a standard component of license agreements. FOSS licenses and FRAND commitments, however, are not standard agreements, as they are founded on ideals of non-discrimination. Termination clauses, which permit licensors to cancel rights of specific licensees, contradict these ideals. The talk will clarify the contradictions between these principles and license termination provisions, explain why termination provisions are nonetheless justified in these models, and illustrate these explanations by reference to a number of current debates.

A fundamental principle of FOSS and FRAND licensing is that the rights under the license must be made available to all end users or willing licensees. The Open Source Definition, for example, expressly provides that open source licenses must not “restrict any party” from redistributing the licensed software, and that such licenses cannot “discriminate against any person or group of persons”. The principles of FRAND licenses are perhaps less sharply defined, but the “ND” in FRAND also imposes a similar requirement of “non-discrimination”.

Notwithstanding these principles, many FOSS licenses provide that licensees that breach the terms of the license can have their rights terminated. FOSS and FRAND licenses may also include “defensive termination” provisions, which allow for the termination of rights in retaliation for patent infringement suits. Such provisions allow licensors to discriminate against specific and identifiable licensees by revoking previously granted rights. Typically, according to these provisions, once a licensee’s rights are terminated the licensor has no obligation to reinstate these rights. Even if the licensor does agree to reinstate the licensee’s rights, the licensor may discriminate against the licensee by imposing restrictions or obligations that would not be permitted under the original terms of the license.

One could imagine an alternative means of structuring FOSS and FRAND licenses that, in hewing more closely to standards of non-discrimination, would not include termination provisions. Licensors would perhaps be required to allow licensees to continue exercising their rights, even as the licensor brings suit against the licensee for copyright infringement or breach of the license. Licensors would not be allowed to impose additional obligations on a licensee in exchange for the reinstatement of license rights.

The talk will advance several explanations of why termination provisions are nonetheless a justified breach of the non-discrimination principles in FOSS and FRAND licenses. Such explanations will include a discussion of the basic principles of non-discrimination and reciprocity in FOSS licenses and FRAND commitments, an analysis of possible remedies available to licensors aside from termination, and an exploration of the legal risks to licensors and licensees of not including termination provisions in the license. The talk will also illustrate the tensions between termination provisions and non-discrimination principles by reference to a number of current debates.

Give a status update on NetworkManager and talk about the current 1.0 release

NetworkManager 1.0 will be released by the time of FOSDEM15.

Talk shortly the major changes from the last year. Show highlights of 1.0 and discuss future plans.

Building a modern monitoring environment is more than just using the latest awesome tools, collecting all of the data, displaying numerous graphs and knowing when things go wrong. A modern monitoring environment is more than tools and infrastructure. It's a service. A service you provide to your whole team: developers, operations, security, and the business. This talk is about how you can build monitoring environments (or extend your existing environment) that are customer-focussed rather than infrastructure focussed. We'll see how you can treat your needs and the needs of your organization as customer requirements and build monitoring that is consumable and configurable on demand.

Building a modern monitoring environment is more than just using the latest awesome tools, collecting all of the data, displaying numerous graphs and knowing when things go wrong. A modern monitoring environment is more than tools and infrastructure. It's a service. A service you provide to your whole team: developers, operations, security, and the business. This talk is about how you can build monitoring environments (or extend your existing environment) that are customer-focussed rather than infrastructure focussed. We'll see how you can treat your needs and the needs of your organization as customer requirements and build monitoring that is consumable and configurable on demand.

We'll focus on:

• What does monitoring as a service look like?
• How do we move to a customer-driven service?
• What tooling do we need to build, change or extend?
• How does this change how your monitoring environment operates?
• What new components and metrics do we need to collect and measure?

By the end of the talk you should be able to build a plan to make your monitoring available as a service to anyone in your organization.

Compact C Type Format (CTF) is a technology created during development of the D-Trace software to describe the C data types. With its second version it evolved into a fully expressive, yet space-wise efficient format that can be used outside of the D-Trace suite too. Compiling the FreeBSD kernel with the CDDL/CTF option triggers the creation of such CTF data that corresponds to the respective kernel objects. This dataset can be parsed and processed to become a source of information needed to pretty print all kernel data structures inside the on-line kernel debugger DDB.

In order to use the CTF technology a new implementation of the format had to be developed - truly multiplatform, freely licensed and supporting different endians. The project had to tackle many difficult problems such as transport of the CTF data to the kernel debugger, which itself is a very limited space. Pretty-printing recursive data structures can be very tricky, as they are implemented as nested struct pointers and the interpretation can lead into unmanageable indentation issues. The solution is to detect certain common types of data structures - lists, queues and trees - and adapt to such structures on a higher level of abstraction.

Apart from the DDB application, CTF data can be used inside user-space debuggers too. As a result of the slim binary design of the format storage, each binary in the whole system, even a production one, can contain the CTF data. To achieve even further minimisation of the space used, a concept of multilevel parent-child relationships was introduced, in which the parent contains the types used in both parent and child and its own, whereas the child has only its unique ones and references the parent set.

This talk is interesting outside of the BSD community too: since the libctf implementation is multiplatform and supports the Debian and OpenIndiana distributions, such pretty-printing functionality could be ported. The CTF toolset - ctfconvert, ctfmerge and ctfdump - is multiplatform as well. Thanks to the free BSD license, the inclusion of such library should not pose a legal problem. Some parts of the project are still work in progress and therefore the community support is much appreciated.

Please do share your impressions of the first day at the distributions devroom. What was great, what can be improved? What would you like to see in the future?

This will discuss the few important details that distribution hackers should know to make sure that their distribution is accessible to everybody.

Freedom #0 of free software is to be able to execute the software. But that is useless if one is unable to actually use the software. Distributions should thus take particular care of their accessibility, which means shipping accessibility tools of course, but also making sure that some accessible software alternatives are packaged, that accessibility can easily be enabled on an installed system, and even that the distribution installer itself is accessible!

Thanks to the experience we have had in Debian in the past years, I will guide the audience through the few important details to know for distribution hackers in order to make sure that their distribution is accessible.

HTTP/2 is the new version of the web's most important and used protocol. Version 2 is due to be out very soon after FOSDEM and I want to inform the audience about what's going on with the protocol, why it matters to most web developers and users and not the last what its status is at the time of FOSDEM.

Daniel is employed by Mozilla and works in the httpbis group within IETF and works with several HTTP/2 implementations. He's perhaps most known as the maintainer and lead developer of curl and libcurl.

Welcome to the MySQL & Friends Devroom

Introduction to Microkernels devroom

Docker containers are generating excitement because of relatable and recognizable use cases and unique facilitation of solutions. One example of this is easy distribution of the container environment. Docker does this with a particular design of images.

In this talk, we will discuss:

• Storage of Docker images: the drivers available as well as some of best practices and recommended performance tunings.
• Notes on the format: how a Docker image is at rest on a daemon versus a registry, and how the image is transferred.
• Verification of images: mechanics of validation and how to return reproducible sums

The goal of this talk is to provide greater awareness of options available for daemon setup, knowledge around the bits in-flight daemon-to-registry, and assurance of this data.

Opening remarks for the Open Source Design devroom

Welcome to the Desktops DevRoom at FOSDEM 2015

A very short intro from the devroom organisers - who is doing this and what organisations support the initiative.

For the development of openconnect VPN server a decision to compartmentalize the server was taken, in order to protect any sensitive values exchanged, ranging from the user transferred data, to the data used during the authentication process. This talk will summarize the issues faced during that development that relate to software isolation. That would cover issues with protecting the server's keys via TLS, the client-side authentication of TLS, and PAM authentication, and how they were solved.

For the development of openconnect VPN server a decision to compartmentalize the server was taken, in order to protect any sensitive values exchanged, ranging from the user transferred data, to the data used during the authentication process. This talk will summarize the issues faced during that development that relate to software isolation. That would cover issues with protecting the server's keys via TLS, the client-side authentication of TLS, and PAM authentication, and how they were solved.

With new PHP versions being released more often, and projects including Drupal increasing their minimum requirements for PHP versions, it's clear that things are changing rapidly. This session is all about the changes introduced in newer versions of PHP (5.3 onwards), and what that means for PHP projects everywhere. There will be practical examples of the shiny new features, advice on finding hosting and safely upgrading existing projects, and news about the performance improvements you can expect as you move between the versions. The way PHP is evolving is truly exciting so come and join in on the fun!

With WAPT, IT teams can manage simply and effectively the lifecycle of an installed base of Windows applications. WAPT can (1) install, (2) update, (3) configure, (4) uninstall and (5) inventory your Windows based applications, be they business, office, utilities or even system drivers.

At CoreOS, we chose to write everything in Go at a time when Python was the language of choice for Linux distributions. It had been almost 10 years since a new Linux distro was created. With the entrance of the cloud era, moving deeply into distributed computing based on Linux containers and multi-core machines, we needed a language that would allow our developers to iterate rapidly and create self-contained components that were not tangled in a web of software dependencies on the operating system. Go was the clear choice because it would enable us to build applications quickly and produce standalone binaries.

With thousands of hours of Go experience, this session will dive into the trenches on Go at CoreOS. It will explore four major projects written in Go: etcd, fleet, rocket and flannel. Attendees will learn tips and tricks for using Go for building and shipping products. Learn the ways Go enables CoreOS to build simple tools to solve a large variety of infrastructure automation tasks, and create high performance components for distributed systems.

This talk will cover some of the major projects written in Go at CoreOS, including etcd, fleet, rocket and flannel. etcd is a highly-available key value store for shared configuration and service discovery, that can be used as a lock service (e.g. for leader election) or for distributed configuration. etcd uses the Go standard library extensively, and the session will detail how we used Go to make our raft implementation lightweight and easy to navigate. Fleet is a distributed init system that extends systemd to the cluster level. The session will explore how fleet uses Go to provide both event-driven and reconcilation-based orchestration of units in a cluster. Rocket is a new container runtime and the first implementation of the appc specification. Developing in Go allowed Rocket to go from concept to functional product in a rapid timeframe. Finally, flannel is an etcd-backed overlay network fabric for Linux containers. Flannel leverages Go’s ability to seamlessly integrate with C code, to provide maximal performance in critical paths but retain the safety of higher level abstractions and ability to leverage existing Go libraries.

seL4, a member of the L4 family of microkernels, and the world’s highest-assured operating system kernel, has recently joined the FLOSS community. This talk will provide an overview of what seL4 is, what it can and cannot do, and where we see it heading in the future.

I will start of briefly summarising the concept of a microkernel, and the core principles which characterise the L4 microkernel family. I will then introduce the core concepts of seL4, and what distinguishes it functionally from other L4 kernels.

What makes seL4 really special is its formal verification. I will explain what this is, and what exactly we have proved about seL4, and discuss what this means in practice, especially as far as security, safety and reliability are concerned. I will also indicate where we are planning to take seL4, i.e. a high-level summary of our on-going research and development projects.

Having covered the technical aspects, I will discuss the development process of the seL4 ecosystem, both past and present. I will specifically discuss the licensing status of various bits of this ecosystem, and how it is likely to develop. In particular I will indicate suggest the best way for the community to contribute to this ecosystem, and help develop it to the benefit of us all.

NOTE: Lecture will be provided via Skype

ProxySQL is a new proxy (currently under development) that aims to become the first open source proxy in the MySQL ecosystem able to provide HA and high performance with no changes in the application, using several built-in features and integration with clustering software.

ProxySQL is a new proxy (currently under development) that aims to become the first open source proxy in the MySQL ecosystem able to provide HA and high performance with no changes in the application, using several built-in features and integration with clustering software. Features under development are: - read/write split ; - queries caching ; - queries filtering and rewrite ; - logging ; - transparent reconnect ; - connection pooling ; - built-in key/value storage ; - integration with clustering solution like MHA for planned and/or automatic failover; - support for master-slave setups (MySQL replication) or multi-masters (NDB or Galera) .

In Southern Kyrgyzstan, large areas are affected by high landslide activity, which regularly results in casualties and economic losses. There have been many efforts in the past and the present to analyze landslide activity in this large data-scarce region. Yet there is a need for creating a system capable of integrating all of the existing information and include the possibility for future updates. Due to the limited funds and multiple end users, minimization of costs and flexible accessibility are requirements for such a system opting for the use of open source software.

The presented tool has been developed as a QGIS plugin. That way, it is possible to take advantage of the core QGIS functionality and other plugins, e.g. the OpenLayers plugin. The plugin allows the user to access the data on landslides, their triggering and predisposing factors in an easy-to-use way. A typical workflow includes querying landslide and factor data for a certain time period and then assigning them to mapping units for further analysis. Besides data queries, the plugin offers tools for spatial analysis, e.g. finding the highest point of the landslide polygon as an approximation of the landslide main scarp, extension of the standard zonal statistics functionality for the derivation of landslide attributes, pixel- or polygon-based calculation of earthquake influence, etc.

GNU Radio is an expansive ecosystem of libraries, hardware interfaces, third-party applications, and community members of all types. With all of these parts, we know it's difficult to understand where to begin. In this lecture, I will provide an overview of the ecosystem and walk through a set of examples that use GNU Radio to explore the wireless space.

Given the huge range of capabilities, available tools, library of third-party applications, and size of the community, this lecture covers a basic introduction to GNU Radio. We will explore, through some historical context, the use of GNU Radio to build some simple applications. Although simple, a key to using GNU Radio is through exploration of the tools and available features, and so the introductory material is meant to overcome the basic difficulties of just getting to know what GNU Radio is and what it can do. With this knowledge that provides an exposure to the library, webpages, tools, and community, we think that other users can continue to explore the space of capabilities and applications for much more advanced features.

A lightning talk about a plugin for QGIS, open source desktop GIS, that enable users at local governments in Flanders to view, save, analyse and create maps with webservices from the Flemish government. This allows them to use live data instead of downloading files from a webpage. This includes Geocoding, Points of interest search, Traffic Obstruction data, Elevation Profile and Data search. slides

We present ViDI, a platform to provide interactive 2D and 3D visualizations of Design Problems in Smalltalk systems. The user can inspect and correct issues in the source code, as well as compare different versions of the same system in terms of design quality. ViDI is built on top of Moose, CodeCity, Roassal, and CodeCritics.

Protecting the confidentiality of cryptographic keys in the event of partial or full system compromise is crucial for containing the impact of attacks. The Heartbleed vulnerability of April 2014, which allowed the remote leakage of secret keys from HTTPS web servers, is an indicative example. PixelVault is a system for keeping cryptographic keys and carrying out cryptographic operations exclusively on the GPU, which allows it to protect secret keys from leakage even in the event of full system compromise. This is possible by exposing secret keys only in GPU registers, keeping PixelVault’s critical code in the GPU instruction cache, preventing this way even privileged host code from accessing any sensitive code or data.

Due to the non-preemptive execution mode of the GPU, an adversary that has full control of the host cannot tamper with PixelVault’s GPU code, but only terminate it, in which case all sensitive data is lost. We have implemented a PixelVault-enabled version of the OpenSSL library that allows the protection of existing applications with minimal modifications. Based on the results of our evaluation, PixelVault not only provides secure key storage using commodity hardware, but also significantly speeds up the processing throughput of cryptographic operations for server applications.

Webapi's are key to firefox app developement this talk will go through the new webapi available in release 2.0 and their impact on Firefox OS architecture. We will go deeper in Gecko and Gonk to see how new webapi can be added with new features in the Gonk/Gecko layer.

The development of cache2k has two streams: It is a robust cache implementation and provides features we miss from other products, on the other hand it is a research area to try out new caching algorithms and implementations to achieve the best performing in-memory Java cache that is available today.

The talk will start with some real-world scenarios and challenges and how the cache can help, making it the pivotal point in an application to manage data resources and provide them on time. The second part of the talk will be about modern and adaptive caching algorithms and why you should not implement yet another "LRU cache" by yourself.

This talk should encourage to use more caching to speed up applications and, of course, to hack and improve existing caching products. There is still much to achieve!

Design and good UX gets more and more important in open source projects. We need to work together, across projects, to deliver the best experience.

In the spirit of open source and sharing code, we should also share our design work. We need to gather, share ideas, exchange how we approach problems, what works and what doesn’t.

Some of the topics we should connect about and also build a body of knowledge for other projects:

• How to get started
• Unique challenges in open source as designers
• How to work together with developers
• Building a design team
• How to make it easy for others to get started
• Resources: tools, blogs, websites, …

And outreach we can do:

• Open Source conferences to attend and present at
• Cross-invitations to conferences of other projects
• Help projects which need design help
• Work with universities to get students working on open source design

The Enlightenment window manager and its libraries have for a long time been seen as one of the pieces of software that might never be released. With E17 taking 12 years for its first release there was some truth in this story. Since we have released E18 and E19 and adopted a time based release schedule for our library releases. Enlightenment still runs on its own schedule.

The Enlightenment window manager and its libraries have for a long time been seen as one of the pieces of software that might never be released. With E17 taking 12 years for its first release there was some truth in this story. Since we have released E18 and E19 and adopted a time based release schedule for our library releases. Enlightenment still runs on its own schedule.

The EFL gets a new release roughly every 3 month. Over a year into my role as release manager of EFL and 4 time based releases later it seems to be a good time to look back and let others know about the lessons I learned to get this working.

The talk will touch topics like setting a release schedule within the community, keep track of the status of git master while progressing, motivate people to invest time in stabilization and tools and automation to keep time effort small. It will touch technical as well social topics involved with release management.

Polygonal meshes are the most common way of representing 2D geometries for simulation purposes. Integrating simulation to a GIS requires storing georeferenced meshes in a databases (or using standard SIG file formats), and being able to use simulation values interpolated over the elements as a map layer.

This presentation reviews what is the closest you can get with existing FOSS GIS solutions and what is needed to bridge the gap, both on the simulation side and on the GIS side.

We show the few lines that need to be added to the simulation code to read a mesh from the GIS and write the results to the GIS. We also present a prototype mesh layer for QGIS that has been implemented as a PluginLayer.

Web maps are everywhere these days, and there are a lot of frameworks that can display a map. But you still have to provide the data yourself. This talk teaches you how to use MySQL with its GIS functions in the database back end for your maps.

MySQL GIS is getting a boost in 5.7 with InnoDB R-trees, new GIS functions and more accurate results. This talk presents the new functionality by leading the audience through a step by step guide to making a simple web map service.

The target audience is MySQL users that want to learn the basics of how to display their data in a map. Users that already know MySQL GIS will learn about the new features in 5.7.

This session will present the current status of integration between oVirt, Docker containers and Kubernetes. It will cover the motivations, some of the low level details and ideas for the future. The second part of the presentation will be dedicated to possible future work within oVirt, ideas for the new concept of multi-purpose data-center and an overview of other projects related to Docker and IaaS.

• Deploying an Application (Old-Fashion and Docker)
• Ecosystem: Kubernetes and Project Atomic
• Current Status of Integration in oVirt
• oVirt Docker User-Interface Plugin
• Dockerized oVirt Engine
• Docker on Virtualization
• Possible Future Integration
• Managing Containers as VMs
• Future Multi-Purpose Data Centers
• Other Projects Related to Docker and IaaS

Welcome to participants and explanation of the day.

Over the last year, we have been using Go to improve the accuracy and quality of our web security scanning system that has become part of our Continuous Development pipeline and now checks all Yahoo websites and changes to them. We would like to present several components of the scanner and share some of our experiences, results, and lessons from using Go for web scanning at a large scale.

Go has caught our attention after the 1.0 release with the approachable learning curve, clean syntax, good HTTP library and built-in concurrency/syncronization primitives and overall a promise of a good match for our tasks. As a warm-up and initial study, we wrote a dead link scanner to plow through thousands of sites and find a number of "bad needles" (404s) - all while running on a single server. Encouraged, we proceeded with converting several parts of the security scanning system to Go.

We started with "webseclab" - set of tests for the scanner and framework to do experiments and proof of concepts/demos. It is similar in spirit to the recently released "firing range", webgoat or DVWA ("Damn Vulnerable Web Application") but thanks to the Go implementation may have special or even unique features.It is extremely easy to fire up (no dependencies and no Tomcat setup or such needed) which allows you to turn any random VM or host into a functional web security "lab". Also, switching between Go's text and html templates, we get "for free" - with just a few lines of extra code - a set of "fixed" tests where the injections are neutralized by proper output escaping which comes especially useful for training and communicating with developers. The webseclab is optimized for rapid addition of new tests and cases - we have been using it to "resurrect" already fixed issues reported through the BugBounty program and quickly convert HTTP dumps into realistic tests ready to be used for scanner improvement.

The next stage of the still ongoing conversion was rewrite of the analysis engine. We named it "contextdetect" as the task of defining the HTML context is crucial for that piece, and here Go has helped us to a break-through. Gone are painful and fragile layers of regexps and scripting logic that were used to simulate HTML parsing and context detection - but still lead to bouts of either false positives or false negatives. We use net/html HTML5 parser [1] to define the HTML context where the injection happens and evaluate it accordingly. We also use Robert Krimen's Javascript parser "otto" [1] to check whether an injection breaks the Javascript (likely bad) or not. Using real parsers allowed us to reduce the number of annoying false positives close to zero and make the life of the tool's users more pleasant - while still finding the real issues (as continously verified with the webseclab). We also implemented in Go a web services wrapper that distributes the work to a number of redundant scanning workers and used "go test" for functional smoke test of the scanner.

In the process of development in our CD environment, we had several challenges with the build process as the standard "go get" approach was off-limits for us and we have a strict requirement to mirror all the 3rd party code used for builds internally. Currently we are using the Android REPO tool to maintain description of the dependencies as well as specify the GOPATH-compatible workspace - we will discuss our considerations of the involved tradeoffs.

While not everyone may have to be as obsessed with defending against XSS and other badness as we are, we hope that our experience will be helpful and encouraging for others who need to do large-scale web or network verification, quality assurance, or investigations. Let's go make the web a better and safer place! :)

[1] https://godoc.org/golang.org/x/net/html [2] https://godoc.org/github.com/robertkrimen/otto

Debugging mobile apps in a world of multiple platforms will always be a classic case of "write once, debug everywhere". A monoculture avoids this problem, but brings a boatload of others, so there is really no way around that. Once we come to terms with this fact however, we can start demanding more from the tools that we use to do said debugging. Do we really have to become proficient in a multitude of tools, one for each platform that we intend to deploy on? How often must we context-switch and app-switch in order to get things done?

The Firefox Developer Tools Adapter presents a unique approach to the aforementioned problem. In this talk we will dive into the design and implementation of the Adapter, explain why it is a valuable addition to the mobile developer's toolchest and discuss how it can be used to solve real-life problems.

With many great tools available for sharing packages of PHP code, it is now up to you as a developer to design these packages well. You have to decide what to put in a package, when to split a package and on what other packages you can safely depend.

You will learn how to make good decisions about your package design and release reliable, highly usable and therefore highly esteemed packages of PHP code.

Join the world of service oriented programming with all its benefits - but without its usually found shortcomings - with Apache Celix. Apache Celix is a framework for service oriented programming in C, with a focus on a low overhead, and a small footprint.

Service oriented programming brings a lot to table. It enables the design and development of software applications in small cohesive modules, which interact based on loosely coupled services.

In this presentation the history and concepts behind Apache Celix will be explained.

Apache Celix

With Apache Celix, C applications can be designed and developed in small modules. Modules run in the same process, but are not visible for each other. When developing applications with Apache Celix it is more natural and compelling to develop modules which do one thing (and do it well), and thus avoiding monolithic and complex applications.

Apache Celix has taken the approach to add the service oriented programming paradigm to the C language without deviating too much from developing plain C, and at the same time deliver a better solution for present-day challenges when working with ever increasing time to market demands and ever changing customer requirements (e.g. Agile Development).

OSGi

Apache Celix follows the Java OSGi specification with some adaptations needed because of the language differences. The OSGi specification is an open standard specification, describing a framework for modular and service oriented development without entailing too much technical details. The specification contains a core specification, describing the minimal OSGi framework, and a considerable selection of compendium specifications: The Event Admin specification for async message, the Configuration Admin specification for decoupling code and configuration, the Remote Services specification for distributed development, to name but a few.

Use a hook framework, written in python to create rules to validate and automate tasks in your git/gerrit environment.

Every r&d department has its own rules and version planning for their product. It might be you're working on a latest (master) branch and at some point (feature freeze), you'll branch into a stable branch for the current version and backport only specific fixes to it. That process can be problematic and not without misses when managing a large scale project such as a virtualization project as oVirt. You'll want to integrate some validation into the process and ensure developers are following the right procedure, like merging fixes in right order (master->stable branch), adding 'bug-url' to the bug to maintain info on the bug fix and so on. In this talk I'll show you a unique system we developed for oVirt that works on gerrit (code review system) and bugzilla api that will run set of verification rules on each patch sent and will ensure patches are treated correctly and with respect! :)

The CHERI research CPU extends the 64-bit MIPS ISA with byte-granularity memory protection. CHERI enables language memory model enforcement and fault isolation in hardware rather than software. In contrast to past capability models, CHERI complements, rather than replaces, the ubiquitous page-based protection mechanism, providing a migration path towards deconflating data-structure protection and OS memory management. Furthermore, CHERI adheres to a strict RISC philosophy: it maintains a load-store architecture and requires only single-cycle instructions, and supplies protection primitives to the compiler, language runtime, and operating system.

This talk will present the CHERI softcore and associated software stack and describe how building on open source has enabled full-stack security research.

2014 saw memory safety vulnerabilities such as Heartbleed in the mainstream press on several times, yet modern CPUs provide a memory model that does nothing to prevent them. Modern security-critical applications such as web browsers split themselves into components to minimise the damage done by a compromise, but are forced to do so using hardware mechanisms (the MMU) designed to protect small numbers of programs from each other and which don't scale to the hundreds or thousands of components that modern software demands.

The CHERI research CPU was created to attempt to apply the RISC philosophy to addressing these problems: To provide a simple hardware primitive that could be used to enforce everything from object-granularity memory protection to library-granularity sandboxing, with the policy under the control of software. The resulting design has undergone several significant revisions and is the focus of ongoing research on OS and programming language security policies.

Our software stack uses a modified FreeBSD and LLVM/Clang, co-designed along with the CPU. This allows us to evaluate real programs, running at a useable (if not spectacular) speed.

At Mentor Embedded/CodeSourcery, we have recently ported LLDB to debug programs for a very specialized processor. This port required a lot of customization in LLDB. We introduced a new connection mechanism to the target and handled new object file and symbols formats.

In this talk, I will describe our experience of porting LLDB. I will explain how to make use of the Plugin architecture of LLDB to customize its behaviour. Finally, I will discuss in details how to write the following plugins.

i) Process plugin to add a new way to connect to target

ii) ObjectFile plugin to handle a new object file format

More and more embedded projects require support for advance connectivity. With it, comes the requirement to enforce a better security as well as private data protection. Using the layer model of Yocto, we show how we can extract from a complex project such as Tizen, advance connectivity and security and apply it to any embedded project.

The Internet of Things (IoT) is growing fast and opens large opportunities to embedded Linux. Unfortunately traditional embedded Linux has been weak when it comes to security and complex connectivity enabling. Tizen which has been developed as a Linux base OS for connected object (phone, TV, car) is on the other side very well equipped in that area. We will start by explaining what is Tizen architecture and how it provides Security and Connectivity facilities on top of a base Linux. We will then show how Yocto and Tizen-meta can be used to create embedded devices which benefit from several years of work done by the Tizen community. In particular we will review : - the mandatory access control enabling in an embedded device - the enforcement of good behavior by applications - resource access control - connectivity layers - HTML5 App enabling. - multi user mode enabling.

OpenJDK comes with a zero assembler port called Zero. Back in 2009 when Zero was originally developed by Gary Benson, OpenJDK was available only on x86, x86_64 and SPARK. Despite recent JIT ports, such as the AArch64 and ppc/aix port, Zero still remains relevant for many Linux distributions. For example, at Red Hat we build and use the OpenJDK zero variant on PPC/PPC64 and s390/s390x. What's more it's a useful tool for getting new JIT ports built from source using free software.

This talk will give a brief summary what Zero is and how it works. It will cover some of the recently discovered issues with sustaining the Zero port, how we try to catch them early and it will explain our experience with pushing fixes upstream. There will also be examples how this effort benefits the OpenJDK ecosystem as a whole.

Learn how to provide bleeding edge features on stable platform using Software Collections that allow you to enjoy different versions of a package or whole application stack on one machine, separately for every process and without influencing the rest of the system. The Software Collections technology is more open than ever before and developed in cooperation with CentOS now. Learn how to use it in practice, what projects use them already and what are the recent changes in the concept.

For last two years Red Hat delivers two major products using Software Collection. Goal is to provide development environments, newer packages like dynamic languages, modules for them, databases to satisfy customer demand on more up to date contant on stable enterprise platform. The lecture will introduce concept of Software Collections, while listeners will learn how to build and use application stack delivered using this technology. Practical examples will demonstrate this unusual combination of stable enterprise platform with latest versions of frameworks like latest NodeJS, Django or Ruby on Rails. Also, tips how to get involved or extend existing collections will be given. The lecture is intended for developers that need to develop applications for enterprise Linux platform but are not satisfied with old versions that are usually delivered on such platforms. Also admins or devops engineers will benefit from being able to install any software without influence the rest of the system.

In systems with high-grade multiprocessing, we have identified two bottlenecks: in the accessing of the memory bus and in the shared resources. To deal with these issues, we propose a dedicated kernel named TORO that is optimized to run a single multi-threading application. TORO is demonstrating an innovative operating system by integrating at the same ring level both kernel and the user application server. In addition, the accessing to resources (e.g., Filesystem, Networking, Memory) is dedicated to specific processor. Then, only the CPU where is dedicated the resource is allowed to access to the instance of the resource. As a result of this design, the kernel provides direct access to all resources without any overhead, and therefore maximizes performance for the overall system. To sum-up the approach, in TORO, the threads of the user application server are distributed evenly on all CPUs and running independently in parallel. The memory model chosen is NUMA without pagination. During the initialization, the memory is divided proportionally for each processor installed on the system. When a thread needs memory, the memory allocator returns a free block of memory depending on which CPU the thread is running. In the same way, TORO can dedicate resources to specific processor, i.e., a FileSystem. This only CPU then can access to this instance of FileSystem. The scheduler is based on the cooperative threading model, therefore due to this design, TORO can migrate threads between CPUs and send messages between threads without using any lock instruction.

I am Matias Vara (http://www-sop.inria.fr/members/Matias.Vara_Larsen/), founder and main developer of TORO (http://sourceforge.net/projects/toro/, http://torokerneleng.blogspot.com/) since 2006. Currently, I am doing a PhD in Computer Science at INRIA, Nice, France. FOSDEM is a very good place to discuss general purpose operating systems vs. dedicated operative systems. This discussion can be motivated by showing the characteristics of TORO by highlighting the main differences with a general purpose OS. The talk will take around 25 minutes.

A presentation of original open source tools created for (and used by) the OpenStack project infrastructure.

Last year at FOSDEM I gave an overview of the OpenStack project infrastructure, a Puppet-driven collection of free software tools which ensure continuous integration at the crazy pace of the OpenStack projects.

While a number of these tools are well-known (Puppet, Jenkins, Gerrit), we also created our own free software tooling to support our unique needs, and those are potentially useful for any software project development infrastructure.

Come one, come all. Step right up and prepare to be amazed! Learn more about Zuul, our fearless pipeline-oriented gatekeeper. Be surprised by jenkins-job-builder, our YAML-driven err... Jenkins job builder. Make Gerrit saner with git-review, JeepyB or gertty. And don't leave without discovering StoryBoard, our amazing future task tracker.

Trying to control multiple computers in live performances is a challenging task. Often computers intercommunicate using fixed or manually configured parameters. However when projects expand across many devices this is hard to maintain, especially in situations where parameters are prone to change. ZOCP is a new protocol which solves this problem by facilitating flexibility and autonomous configurations in an orchestrated environment.

In this presentation we present the ZOCP protocol which overcomes the situations mentioned below. The ZOCP protocol is designed with the following in mind:

• KISS (Keep it simple and stupid): We want this protocol not be in our way and we want to be able to understand it easily.
• Zero Configuration: The protocol should be able to handle most, if not all configuration by itself. There is no need for setting up specific parameters unless requested, aka convention over configuration.
• Runs on anything TCP/IP: Since TCP/IP is the de facto standard for devices to communicate the technology should be able to run on any device that is able to talk TCP/IP
• Open Standards: All used technologies, software, protocols should be freely and openly available.
• Low latency, when needed
• Reliability, when needed
• Unintrusive debugging and monitoring

As artists embrace new technologies as an artistic medium, these technologies often provide artists with new methods for cooperation. Networking technologies are used frequently for these purposes. Internet has been a driving force behind the development of networking hardware and open standards for connecting any to device to any device. These technologies are now a commodity and thus available for anybody to use. However we see a rising need to be able to implement these technologies in a flexible adaptive manner without the explicit fixed configurations requiring manual configuration.

Open Sound Control (OSC) is a protocol developed for exchanging music performance data. OSC is often used as an alternative to MIDI, however, it has found its way to many use cases besides musical performances. We have found OSC to be an ideal de facto standard for connecting applications to each other in order to orchestrate them. However the flexibility of OSC tends to decrease exponentially when used in large configurations because of its hard-coded nature. This implies that many applications need to be instructed to use specific manual settings and agreements in order for applications to communicate. In large configurations containing multiple systems and multiple applications, this manual work is inflexible and error prone.

The current prototype is developed using the ZeroMQ framework. We will demonstrate the protocol in a setup with Blender, a game engine, an Urwid console monitor and a RaspberryPi.

Mold your development environment. Your system is too special to leave it in the hands of generic tools. The Glamorous Toolkit (GT) brings a new generation of easily customizable development tools.

The Heartbleed vulnerability made one thing very clear, current TLS stacks lack an efficient way to isolate the cryptographic material from the application layer. Hence, this vulnerability required the massive renewal of private keys and certificates. This sure was a costly and painful process for IT departments. The most efficient approach consists of using Hardware Security Modules or smartcards to store the cryptographic material. Keys remain confidential while being usable through an API to perform cryptographic operations. PKCS#11 is a standardized security API that is widely adopted by device vendors. However, deployment of such hardware can be costly and inconvenient in many scenarios. We propose using Caml Crush, a PKCS#11 filtering proxy, in combination with software PKCS#11 tokens. This architecture leverages process isolation between the TLS stack and the cryptographic material. This low-cost alternative is immediately applicable to PKCS#11 compliant software. We demonstrate that this architecture has a low performance overhead by benchmarking the impact on web hosting scenarios.

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: 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). The project goals are ambitious. This talk aims at presenting what Qucs can offer as well as tease the audience into thinking what is achievable with the open-source EDA tools available today.

I would like to talk about the next generation of Ubuntu, currently working on phones and, mostly, on tablets.

We're building it out for traditional windowed use cases now, ultimately enabling convergence, i.e. using one device to drive all your computing (mobile or otherwise) needs. I'll talk about how we want to get there

MySQL 5.6 introduced Global Transaction IDs to make the reconfiguration of replication straightforward. The key benefit is that you can instantly and reliably change your replication topology if a node goes down or if the current topology no longer fits your needs. But of course operating a GTID-based cluster brings new challenges: old habits no longer work, tools have changed, and new issues have appeared.

MySQL 5.6 introduced Global Transaction IDs to make the reconfiguration of replication straightforward. The key benefit is that you can instantly and reliably change your replication topology if a node goes down or if the current topology no longer fits your needs. But of course operating a GTID-based cluster brings new challenges: old habits no longer work, tools have changed, and new issues have appeared.

In this session, you will learn about using GTIDs in production, including: - How to execute the daily DBA tasks related to GTID-based replication, such as monitoring replication status or recovering from replication errors - The new options for high availability and the tools that can help you - What can go wrong when using GTIDs

You see beautiful maps every day, you use geospatial data every day but do you know what's behind processing all the big geospatial data? With the advent of open geospatial data in Europe new opportunities arise. In our presentation we show GRASS GIS (Geographic Resources Analysis Support System, http://grass.osgeo.org), a software suite for geospatial data management and analysis, image processing, graphics and map production, spatial modeling, and visualization. The software has been developed as FOSS for more than 30 years by a large community of developers and users. After six years of development and a long beta release cycle the new stable GRASS GIS 7.0 release is imminent. GRASS GIS 7 is rich in functionality, it offers e.g. enhanced vector network analysis, voxel processing, support for massive time series data management, an animation tool for raster and vector map time series, a graphical image classification tool, and a "map swiper" for interactive maps comparison. The software is portable among most operating systems including GNU/Linux, Mac OSX, FreeBSD, AIX, SUN Solaris, other Unix based, and MS-Windows.

GRASS GIS 7 offers a new Python API (PyGRASS) for rapid development of workflows. For working teams, it supports shared data management on networks. It can be used as a geoprocessing backend for Web Processing Service (OGC WPS). For statistics, it comes with an interface to R statistics.

In our research context, we use GRASS GIS extensively for massive geospatial data analysis on a high-performance computing system (HPC). In our presentation, we illustrate workflows and results using "EuroLST" temperature dataset (http://gis.cri.fmach.it/eurolst/) as an example of data in the multi-terabyte range.

The Radio Data System (RDS) is a digital subcarrier on ordinary FM radio broadcasts that is used to convey a bunch of information including station name, time, alternate frequencies, and optionally traffic information with the Traffic Message Channel (TMC) protocol. Given its ubiquity, narrow bandwidth demands, and frequency band, RDS might be a good first digital project for SDR newcomers, extending the 'Hello World' of SDR, i.e., the FM receiver. RDS can be received with very cheap hardware like the RTL-SDR and simple antennas making the technology accessible for everybody.

In this talk, I will give a short introduction in RDS / TMC and present the current state of the GNU Radio RDS project. Besides the receiving part, we will also have a brief look in the transmit side that allows you to create your own small radio station including RDS and TMC messages. The information is hopefully just enough to whet your appetite and helps to get you started.

Presenting challenges, experiences and a possible solution for problems we face in FLOSS, when we try to understand our users.

Usability or User Experience essentially is optimizing a software for users needs. To accomplish this, we need to know who the users are, what they think, do and want to achieve with our tool.

In Free Software projects this kind of work often is especially difficult. Our work can be distributed freely, so we do not know who or even how many people are using our product. And we usually do not have enough money to do market or customer research to fill this gaps. Finally, developers have become good to ward off anything that doesn't scratch their own itches. And without real user data, we often lack "objective" arguments to win developers to implement changes needed.

With this talk, I want to reflect on my experiences with user research and user driven design in different FLOSS projects, esp. KDE and LibreOffice. Based on this, I will present an idea, how tooling could possibly improve the situation. And, of course, I want your feedback on all of this!

CRIU (checkpoint/restore in userspace) is a project, which allows to dump a group of processes on a disk and restore them back later on the same or another host. Another significant use case is online (iterative) migration of Linux Containers.

CRIU (checkpoint/restore in userspace) is a project, which allows to dump a group of processes on a disk and restore them back later on the same or another host. Another significant use case is online (iterative) migration of Linux Containers. CRIU project was born in OpenVZ team to replace their in-kernel realization.

There was a talk here about CRIU two years ago. In that time CRIU was a young project and we needed to do a lot of things to be ready for real use. Now CRIU is mature enough, the main functionality is completed. People are getting more and more interested in the project. They are integrating CRIU into their own projects.  Our community becomes bigger. There are more than thirty people from Parallels, Canonical, Google, Docker, etc.

The talk will cover following questions: * How does this work? * How to integrate CRIU in another project? * What are the most interesting use cases? * What are the current state and future plans? * How are we caring about quality?

This talk will present LuaRocks, the package manager for modules for the Lua programming language. Lua has successful as a scripting language embedded into applications, especially in the gaming industry. However, its "no-batteries-included" design prevented it from getting traction as a stand-alone application language. LuaRocks was created to target this problem. This talk will discuss the particular challenges of developing a package manager for Lua. With this project, we've been successfully fostering an ecosystem of extension modules, improving reuse of Lua code.

Full Description

This talk will present LuaRocks, the package manager for modules for the Lua programming language.

Lua has been used for many years as a scripting language embedded into applications. It has been especially successful in the gaming industry, being present in several AAA titles. Its ease of embeddability, good performance and small footprint have been major factors it this success.

However, its minimalistic, "no-batteries-included" design has also prevented it from getting much traction as a stand-alone application development language. A major setback was the lack of an easy way to integrate extension libraries for various tasks (such as sockets, databases, UI, XML/JSON, etc.)

LuaRocks was created to target this problem. It is a package manager designed for Lua modules (written in Lua or C). It serves both as a package manager in the style of RubyGems or npm, and also as a build system for compiling C code into Lua modules.

This talk will discuss the particular challenges of developing a package manager for Lua. Some are technical challenges, related to portability; some are social challenges that reflect into technical issues, such as the lack of established practices.

With the LuaRocks project, we've been successfully fostering an ecosystem of extension modules for Lua. The repositories keep growing, and the dependencies between modules show that reuse is increasing.

About the presenter

Hisham Muhammad (Rio de Janeiro, Brazil) — lead developer of LuaRocks. PhD student at PUC-Rio, the university where Lua is developed. Other projects include htop and GoboLinux. I've been involved with the Lua community since 2004 and I have given talks on Lua-related topics in a number of conferences.

GRASS offers different APIs that allows interested developers to contribute. From the core C-API to the very lightweight Python scripting library, each plays a different role and their coexistence can cause some confusion. This lightning talk aims at clarifying the role of each of these APIs.

GRASS is originally a C project. However, there has always been command line scripting and some of these scripts have been integrated into the core distribution. With the upcoming GRASS 7, Python has been chosen to replace bash as the main scripting environnement, based on a lightweight scripting library leveraging the modular character of GRASS. At the same time, the need was felt by some to dispose of a more low-level access to GRASS functionality in Python. This has led to the development of pygrass, based on ctypes, which provides as more complete, more pythonic, object-oriented approach to GRASS script programming.

This talk will briefly introduce the different APIs and explain different use-cases and user-types for each of them.

Universal 2nd Factor is the next step in hardware-assisted authentication for cloud services and more. U2F specify a USB-based protocol for offloading the private-key handling for strengthening username/password logins, and is supported by Chrome and Google (for gmail.com users) since October 2014. By using dedicated hardware that require physical presence, issues with common solutions (one-time-password or certs) are improved on. This talk will be about the U2F protocol, and the free software implementations that we are writing. There will be hands-on demo of the user-experience and also details about the implementation.

Future of java applets and javaws is dark. Chrome have already cut down NPAPI. Most of the banks moved from java to javascript for they internet banking. The javaws will suffer a lot by introducing jigsaw modules. What is remaining? The "physical applets" of course! Seriously - the "killing" feature of applets is that they do not work offline. But similarly to javaws - they can! IcedTea-Web is now removing this boundaries, and what more, it will also allow you to detach applet out from browser - by jnlp shortcut, or by lunching html page by javaws directly. Apart of this, ITW is now JDK independent and you can run those features on any OpenJDK, even on Oracle or IBM JDKs. And except serving you web application comfortably online, ITW allows you to lock this application - even "signed ones" in sandbox. And of course there is Jogamp project - the awt-less plugin - How I wish to see it merged upstream!-) Long story short, more security and much much more freedom

This talk will focus on how to adapt an existing distro like Tizen to the IoT world and try to answer some questions:

• how 'small' is an IoT device ?
• why starting with Tizen ?
• what are the consequences on the software architecture ?
• which adjustments for which components ?

Topics:

• How 'small' is an IoT device ?

  • memory size, CPU power
  • headless or not ?
  • wireless or not ? (which connectivity)
  • power consumption

• Why Tizen ?

  • OS for everything !
  • connected
  • secure
  • Yocto-enabled

• Tizen architecture revisited

  • Tizen APIs
  • • Wearable APIs
  • • OIC APIs (or AllJoyn APIs)

• Tizen components to adjust:

  • linux kernel
  • display system: framebuffer (no GPU)
  • no graphics server (no weston, no X11)
  • embedded crosswalk on framebuffer
  • systemd -> uselessd
  • others ...

The purpose of this talk is to demonstrate and explain how to use and modify GNURadio and GNU Radio Companion to interact with consumer devices on an IEEE 802.15.4 network. Accompanying the talk will be slides documenting the hardware, software, and network architectures for the demonstration, with specific attention to GNU Radio hacking and rapid prototyping of software to interface with most commercially available SDRs.

This was a big year for the Internet of Things. Both Apple and Google announced their venture into the Home Automation consumer market. Having reliable and extensible tools to interact with the IEEE 802.15.4 spectrum is incredibly important for developers and engineers of wireless products, as well as for security researchers.

Using off-the-shelf SDR equipment (e.g. the USRP B200 from Ettus Research), as well as off-the-shelf Home Automation hardware and software, developers can easily interact with an IEEE 802.15.4 network and do everything from pretending to be a light bulb to packet sniffing and network management.

This talk will go over some of the challenges encountered in designing such a node with the help of GNU Radio, GNU Radio Companion, and freely available 802.15.4 code.

Pseudo GTID and easy replication management

This session introduces a technique called “Pseudo GTID” which allows easy refactoring of replication topologies, and makes balanced, deeply nested topologies achievable, safe and productive.

Managing large replication topologies introduces difficult questions: do you place all your slaves directly under the master? Do you setup intermediate masters thus creating deep replication trees? How do you synchronize sibling slaves when their master dies? How do you recover replication of a slave if its intermediate master is gone?

MySQL’s Global Transaction ID (GTID) comes to solve the above. However GTID comes with its own limitations and not always or not easily applicable.

Pseudo GTID is a non intrusive solution that utilizes standard replication, and turns your existing replication topology into a GTID-like topology, allowing you to repoint slaves however you like.

We will quickly discuss the problems incurred by standard binary log file & position setup, and the limitations of GTID, Pseudo-GTID injection. We will present the algorithm and implementation for utilizing Pseudo GTID to freely repoint slaves.

Context is a Smalltalk distribution with a minimal object memory and a distributed module system. I will demonstrate distributed operation on a small local network of machines, focusing on use cases for remote team development.

With the web slowly maturing as a platform the demand for cryptography in the browser has risen, especially in a post-Snowden era. Many of us have heard about the upcoming Web Cryptography API but at the time of writing there seem to be no good introductions available. We will take a look at the proposed W3C spec and its current state of implementation.

Ngspice project started in 1999 from the latest implementation of of Berkeley's SPICE3 release. In more than a decade of development it has fixed and upgraded it. Parallel execution of device code has been implemented to reduce simulation time for transient analysis. Two implementations are available: using OpenMP and CUDA. The KLU solver has been implemented to reduce simulation time of large circuits. Verilog-A models can be included at compile time using the ADMS model compiler. This presentation will show an overview on the simulator status focusing on the major improvements over the original SPICE3 code.

openSUSE Factory is the head development branch for the openSUSE distribution releases. As such the explosive mixture of changes and new versions throughout the whole stack from kernel to the desktops made openSUSE Factory a challenging distribution to use even for hard core distribution hackers. To make Factory usable for a wider audience of distribution developers it had to be made more stable while retaining the short turnaround times needed for a bleeding edge distribution. openSUSE therefore introduced a number of automated and semi-automated tools for review and QA into the development workflow to reach that goal. The result is now called openSUSE Tumbleweed, a fully rolling binary distribution based on openSUSE Factory. This talk explains the development process and the tools used to turn openSUSE Factory into Tumbleweed.

Target audience are distribution integrators in general. All of them have problems like "does this new dracut submission break the installer or render the system unbootable?". With the process used by openSUSE many such questions can be answered by the machine, automatically. The process outlined in this talk is not only useful for rolling distributions like Tumbleweed but also for stable releases. It helped significantly to increase the quality resp avoid regressions between beta and RC versions during the release process.

MongoDB is one of the most popular databases in the world to date and we love Go. As part of MongoDB package comes a set of tools and utilities that allow the user to perform several different tasks on MongoDB like exporting data, important, collecting stats etc. Part of the ecosystem around MongoDB is also MMS(MongoDB Management Service) which allows users to monitor, backup and automate their MongoDB deployments using a centralized SaaS service. MMS agents are already Go applications and we are also migrating MongoDB tools to Go codebase, among other internal tools. This is potentially the largest distribution of Go applications to date in an opensource project!

This talk explains why we’ve undergone such code base change, our expectations and the actual benefits that we are already seeing due to this change: better code base better testability better deployment / multiplatform (goodbye #IFDEF statements in C++ code base) better performance The talk is oriented to people looking to make a similar task of changing their current apps to Go, people looking to understand the pros and cons (mostly pros) of using Go for such set of utilities and agents and for people interested in understanding how to manage a Go code base distribution.

AArch64 is ARM's 64-bit architecture. I'll present a short history of how the AArch64 support in LLVM was implemented, a summary of which general AArch64 features are well supported by LLVM and a summary of which areas need more work.

GCompris is a high quality educational software suite comprising of numerous activities for children aged 2 to 10. It was created in 2000 using the GTK+ graphical toolkit. It is available on different platforms, GNU/Linux, and the proprietary platforms MacOSX and Windows.

Willing to address the large number of tablet users and to enhance the user experience the choice was made in January 2014 to rewrite GCompris in Qt Quick.

The presentation will address the following topic:

• Project goal and history
• Community and commercial. Starting in 2003 a Windows version was created and is distributed under a commercial model while being still Free Software. We will see how and why we decided to do so
• Why we selected Qt Quick. This development toolkit is based on Qt and let the developer create dynamic user interface that can run on desktop and mobile platforms
• Why we became a KDE project. GCompris has always been a community project, leaving the GTK+ toolkit it does not make sense to develop the new version under the Gnome umbrella
• State of the Qt Quick port
• A short Qt Quick presentation
• A live coding session where showing how easy it is to create a new educational activity for GCompris

At OpenChange, we work on offering a portable Open Source implementation of Microsoft Exchange Server and Exchange Protocols. During the past 10 years, we have seen the community growing but not the number of developers. The conclusions were clear. The price to pay to develop on OpenChange was too high: C language only, very complex, too much knowledge required, too much time before you get visible results. We have addressed all these obstacles and will teach you during this talk how to set up the development environment in no time, understand the basics of the OpenChange REST API and leverage its resources and samples to get first visible results in Outlook today.

In Geo service terminology, coverages represent spatio-temporally varying phenomena, such as sensor, image, simulation, and statistics data; incidentally, these typically are prime Big Data contributors in practice. The OGC unified coverage model encompasses regular and irregular grids, point clouds, and general meshes. As opposed to the (abstract) coverage model of ISO 19123, the (concrete) OGC coverage and service model establishes verifiable interoperability while still grounding on ISO 19123. The OGC Web Coverage Service (WCS) comprises a modular suite for accessing large coverage assets. WCS Core provides simple data subsetting whereas extensions add optional service facets up to ad-hoc filtering and processing.

By separating coverage data and service model, any service - such as WMS, WFS, SOS and WPS - can provide and consume coverages in addition to WCS. Generally, the WCS suite is appreciated by implementers due to its clear structuring and concise conformance testing, down to pixel/voxel level. Many WCS implementations are available today, such as rasdaman which has proven efficient on 130+ TB datacubes.

In our talk, we present the OGC coverage data and service model with an emphasis on practical aspects. Presentation will make use of available services allowing participants to recapitulate many of the facets addressed.

Distribution to multiple virtual machines in the cloud or servers is the way to scale horizontally when there is no more room or resources to grow vertically. In this talk we will discuss how to load test an XMPP server and distribute load generation using Erlang/OTP as a platform. Experiences from testing production ready MongooseIM systems will be presented.

Talk objectives: show from the ground up how to plan and execute load tests of a distributed service and distribute load generation.

Talk audience: DevOps people wanting to load test their XMPP or other message oriented services. People evaluating XMPP solutions in terms of capacity and scalability.

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.

At its core is a set of group communication primitives that act as the building blocks to create reliable, consistent and dependable messaging between the servers in the group. This allows the set of MySQL servers to coordinate themselves and act as a consistent and replicated state machine - in which transactions commit in the same order on every server. As a consequence, the group itself is fault-tolerant, and so is the service provided by the group - the MySQL database service.

In addition to HA, the plugin provides multi-master update everywhere with row-level conflict detection. This builds on the fact that the servers in the group have to agree on how to progress the replicated state machine and so also check for conflicts.

Come and learn about the technical details of the exciting and popular MySQL Group Replication plugin and discuss how this fits in the overall picture of MySQL HA solutions.

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.

At its core is a set of group communication primitives that act as the building blocks to create reliable, consistent and dependable messaging between the servers in the group. This allows the set of MySQL servers to coordinate themselves and act as a consistent and replicated state machine - in which transactions commit in the same order on every server. As a consequence, the group itself is fault-tolerant, and so is the service provided by the group - the MySQL database service.

In addition to HA, the plugin provides multi-master update everywhere with row-level conflict detection. This builds on the fact that the servers in the group have to agree on how to progress the replicated state machine and so also check for conflicts.

Come and learn about the technical details of the exciting and popular MySQL Group Replication plugin and discuss how this fits in the overall picture of MySQL HA solutions.

Matrix is a new, pragmatic HTTP-based clean-room alternative to XMPP, SIP, IRC and other messaging/VoIP technologies. It consists of an open standard defining RESTful HTTP APIs and open source, Apache-licensed reference implementations for creating and running your own real-time communication infrastructure for VoIP/IM or any other service that includes sending binary data around - including IoT services.

Matrix is a set of pragmatic RESTful HTTP JSON APIs presented as an open standard, intended to be implemented on a wide range of servers, services and clients, letting developers build functionality on top of the Matrix ecosystem for messaging, VoIP and a multitude of other services.

In Matrix, every user runs one or more Matrix clients, which connect through to a Matrix "homeserver" which stores all their personal communication history and user account information - much as a mail client connects through to an IMAP/SMTP server. Just like email, you can either run your own Matrix homeserver, which means you own and control your own communications and history - or you can use one hosted by someone else (e.g. matrix.org) - there is no single point of control or mandatory service provider in Matrix. In fact, there is no single point of control over conversations in Matrix at all - conversation history is a first class citizen, with room state replicated over all participating servers, avoiding single-points of failure or control as you get in XMPP MUCs.

With the continously increasing number of devices connected to the internet, we need ways to gather and unify all the status and instruction data going back and forth - and Matrix is a perfect fit for these kind of services.

Pharo can be used on much more than just a Linux, Mac or Windows pc. The vm is rather easy to port as most of the code is written in Slang, a Smalltalk subset that easily compiles to c.

SDCC is a standard (ANSI C89, ISO C90, ISO C99, ISO C11) C compiler targeting 8-bit architectures (MCS51, DS80C390, Z80, Z180, Rabbit 2000, Rabbit 3000A, GBZ80, TLCS-90, HC08, S08, STM8, PIC). It works on many host systems (Linux, Windows, Mac OS, Solaris, NetBSD, FreeBSD, ...). The talk starts with a view on SDCC from a user perspective - standard compliance, targets. There is a short interlude on how the SDCC project is set up. The second part is about some of SDCC's unusual optimizations currently not found in any other compiler, in particular an optimal register allocator and bytewise register allocation.

The presentation will be held jointly with sdcc developer Maarten Brock.

Deploying containers, images with Docker is becoming a big trend. However, large installations of containerized applications are still few and far between, and solutions are either proprietary or they force you to use their own cloud.

We believe Foreman can fill this space by providing a central space to provision and manage your containers and your network, as we already do with your data center. This provides a great framework for mixed environments where physical machines, vms, and containers are all used in conjunction. Orchestration through Kubernetes is being implemented at the moment.

Monitoring, deploying, and everything else is possible to do through the web UI or an API, and it's open source, so if you miss any feature, feel free to add it!

Deploying containers, images with Docker is becoming a big trend. However, large installations of containerized applications are still few and far between, and solutions are either proprietary or they force you to use their own cloud.

We believe Foreman can fill this space by providing a central space to provision and manage your containers and your network, as we already do with your data center. This provides a great framework for mixed environments where physical machines, vms, and containers are all used in conjunction. Orchestration through Kubernetes is being implemented at the moment.

Monitoring, deploying, and everything else is possible to do through the web UI or an API, and it's open source, so if you miss any feature, feel free to add it!

We've been working on OpenJDK for a long time now and we've gained a lot of experience working on the code itself and, perhaps more importantly, working with the Java team inside Oracle. This talk is about our experiences trying make one of the largest ever external contributions to OpenJDK, the AArch64 port.

I'll talk about how the OpenJDK contribution process works, and how it doesn't work, and how important it is to gain the trust of people inside Oracle's Java team. I'll discuss the strange asymmetry of being an external contributor to a project but not being able to know all of what is going on. I'll try my best to explain the baffling role of Projects and JEPs. I'll speculate about the future of OpenJDK and how it must change as more people outside Oracle contribute significant slabs of code, and how we must have more external patch reviewers.

Finally, I'll open up the floor for discussion. I'm sure we'll have a lot to talk about.

It's nothing new that speed is important for the success of any web application. Only a few hundred milliseconds may lie between a user leaving your site or staying. Unfortunately performance problems are oftentimes hard to fix and even harder to pinpoint. In this talk I will show you how we at ResearchGate measure web application performance, which means not only timing how long the PHP backend took to deliver a page, but also tracking the speed the users actually perceives in the browser. After that you will see how you can track down and analyze any problems you found through measuring with the help of tools like Xdebug, XHProf and the Symfony Debug Toolbar. And if you still need to get faster after optimizing and fixing all these issues, I'll introduce you to some tricks, techniques and patterns to even further decrease load times.

Wine has seen gradual improvements in its support for games and game performance over the year. This talk gives an overview over the past changes, upcoming work as well as the opportunities and problems of the Direct3D9 implementation in Mesa.

Theano is an exciting relatively new open source library which was developed by the machine learning community to accelerate the training of Deep Neural networks and other mathematical algorithms built on scipy by generating compiled kernels for the CPU and the GPU using the CUDA compiler and simple python algorithm definitions. Since GNU Radio provides native python blocks which execute work functions directly on scipy-style input and output vectors joining these two technologies is a magical approach which allows for the extremely rapid definition of work block mathematical kernels, and the automated compilation and offload onto massively parallel graphics processing unit hardware. By using this approach we will demonstrate how some highly concurrent and computationally expensive algorithms can be implemented extremely concisely and executed efficiently using graphics processors to accelerate GNU Radio channel models and other blocks with minimal effort. For more information on Theano see: http://www.iro.umontreal.ca/~lisa/pointeurs/theano_scipy2010.pdf and http://arxiv.org/pdf/1211.5590.pdf

Now more than ever, users clamor for software that respects their privacy and protects their security. Free software's natural advantage is that it's almost always the best option to safeguard users in a world where proprietary software so often betrays them. Users want options and we know developers want to provide them, so what are we missing?

When an alternative to a proprietary system becomes available, people don't seem to stick with it. Users arrive and things break, features that seem basic are missing, and the channels through which they might ask for help are hard to find or non-existent. They're wondering, "Who did you build this for? Why is it so annoying to use?" Meanwhile, developers put their time and energy into building technology to free their users and are left wondering, "Why aren't people just using this? It's not really that hard to figure out."

Two free software activists, one developer and one community liaison, take turns asking each other questions about their experiences and goals. All the questions about intent and process that you've been wondering about will finally be answered. At MediaGoblin, we've worked hard to keep the lines of communication between developers and users open from the beginning. This public conversation between MediaGoblin's technical founder and community liaison will replicate some of those conversations for the audience. Our back-and-forth interview will share what we have learned about how free software projects can get users to show up and, more importantly, stay.

EIFFEL the language and SCOOP(*) allow the creation of a kernel without neither MMU nor processes but secured.

The removal of MMU and processes improves the switching time of contexts and minimize the memory cost of concurrency. The kernel provides unlimited concurrency and native synchronisation/acquiring of multiple resources.

The security is primarily given through EIFFEL's exports at the API level and is enforced by tightly coupling the kernel and the compiler. The low-level unsafe API are available only available to the kernel.

(*) SCOOP: Simple Concurrent Object-Oriented Programming

The common state of the art is focused on POSIX implementation: C programming, processes, threads, mutexes, etc... But this has some issues: one stack per thread with strong separation of processes made by the use of MMU.

By changing the language, this concepts are becoming obsoletes and the issues disappearing. But the security remains and even more is enforceable at an API level.

SCOOP, the Simple Concurrent Object-Oriented Programming, is expressing the concurrency inside the language (without need of IPC or IDL) by linking (sub)systems to abstract processors.

Each of the SCOOP abstract processor has its own isolated memory. The FLK (http://flhq.org) implementation ensures the isolation of the memory at the language level. This done, no MMU is no more needed. Yes, the memory is managed by the kernel, but using only one common addressing space, a flat model.

SCOOP provides the model of synchronizing multiple resources. This synchronisation is native and is made using Rhee's algorithm that can be distributed. Having this avoid any need of mutexes, semaphores.

Conversely, this model tends to multiply the count of abstract processor in a way that can not be implemented using threads because of their weight. But it allows to change the underlying mechanism. Abstract processors are not executed within a private context/stack but on the current execution context that crosses processors.

New security behaviours tends to include security at the API level. The coupling of the compiler with the kernel allow to enforce this behaviour at compile time, installation time and (if very paranoiac) at runtime.

A retrospective on Rust 1.0!

The Rust programming language is just about to hit its 1.0 release. It's been a very long time coming, and in this talk, I'd like to give a retrospective on Rust's history, and show you how it came to be today. A teaser: Rust has lost many more features than it's actually gained!

Let's review together what happened with Firefox in 2014 and where we are headed in 2015.

For the past 4 years, FastMail has been working on a next generation email protocol for our web interface. We have years of experience writing email clients and servers, and we know where the pain points are. This protocol is in production right now, and a 30 second demo will show it in action.

At the moment the email world is divided. Every vendor is building their own proprietary JSON protocol, because IMAP+SMTP is a really poor fit for mobile apps and even the LEMONADE protocol changes haven't made the experience good enough.

We want to change that by offering a completely unencumbered standard which is good enough that companies don't need to build their own, and gain an interoperability layer which is better for everybody. Raise the baseline experience if you will. We believe it's possible to have a protocol which is both open AND good.

In April 2014, the American National Institute of Standards and Technology (NIST) published the draft FIPS 202 standard for the SHA-3 hash functions and the SHAKE extendable-output functions (XOFs), all based on the Keccak sponge function. Since the selection of Keccak as the winner of the SHA-3 cryptographic open competition, NIST announced that they will exploit Keccak's abilities for other purposes than just hashing, including key derivation, pseudo-random bit generation, authentication and (authenticated) encryption.

A first part of the talk will be to give a summary of the current developments around Keccak and the FIPS 202 standard.

In the meantime, we have gathered the most efficient implementations of Keccak, SHA-3 hash functions and SHAKE XOFs in the Keccak Code Package. These open source implementations are organized in a way that aims satisfying both the developer of optimized code and the cryptographic user. Central to this organization is a specific internal interface that allows interchangeable optimized codes and a user-friendly set of external services.

As a second part of the talk, we will briefly present the current status of this development and how the FOSS community can benefit from (and contribute to) this effort.

This is a follow-up of the talk "Keccak: more than sha3sum" at FOSDEM 2013.

Compact/SPICE models of circuit elements (passive, active, MEMS, RF) are essential to enable advanced IC design using nanoscaled semiconductor technologies. Compact/SPICE models are also a communication means between the semiconductor foundries and the IC design teams to share and exchange all engineering and design information. To explore all related interactions, we are discussing selected FOSS CAD tools along complete technology/design tool chain from nanascaled technology processes; thru the compact modeling; to advanced IC transistor level design support. New technology and device development will be illustrated by application examples of the FOSS TCAD tools: Cogenda TCAD and DEVSIM. Compact modeling will be highlighted by review topics related to its parameter extraction and standardization of the experimental and measurement data exchange formats. Finally, we will present two FOSS CAD simulation and design tools: ngspice and Qucs. Application and use of these tools for advanced IC design (e.g. analog/RF IC applications) directly depends the quality of the compact models implementations in these tools as well as reliability of extracted models and generated libraries/PDKs. Discussing new model implementation into the FOSS CAD tools (ngspice and Qucs as well as others) we will also address an open question of the compact/SPICE model Verilog-A standardization. We hope that this presentation will be useful to all the researchers and engineers actively involved in the developing compact/SPICE models as well as designing the integrated circuits in particular at the transistor level and then trigger further discussion on the compact/SPICE model Verilog-A standardization and development supporting FOSS CAD tools.

FOSS CAD for Compact/SPICE Modeling W.Grabinski and D.Tomaszewski

Tutorial on how to start developing useful smart card applications for real life smart cards in less than a day.

Overview of smart cards and specifically JavaCard platform and a description of what is needed for development and testing and how everything can be accomplished with minimal money and mostly open source tools. Dedicated smart card applications allow to isolate critical keys or even generic code into small, secure devices that can be kept in a safe.

The next billion people to come online will do so through their phone. If they don't have access to awesome mobile web content, their experience will be controlled by the app ecosystem of the phone they purchase.

Help them - and all your friends - by making sure that all the websites and apps you create are great mobile experiences. Increase your reach to mobile and make sure that everyone has access to your content by creating a discoverable, responsive, awesome mobile experience on the web.

Why? 1) All mobile users have access to the web. Not all mobile users will download an app. 2) Web pages are more accessible through search. 3) All users, regardless of their platform, have access to mobile websites. 4) Nobody is censoring content, nor taking part of the profits, on the web. 5) Everyone can create mobile web content without needing third party approval. 6) Your mobile website can easily become an app for mobile platforms.

The next billion people to come online will do so through their phone. If they don't have access to awesome mobile web content, their experience will be controlled by the app ecosystem of the phone they purchase.

Help them - and all your friends - by making sure that all the websites and apps you create are great mobile experiences. Increase your reach to mobile and make sure that everyone has access to your content by creating a discoverable, responsive, awesome mobile experience on the web.

Why? 1) All mobile users have access to the web. Not all mobile users will download an app, especially for things they do once or places they visit infrequently. 2) Web pages are more accessible through search. 3) All users, regardless of their platform, have access to mobile websites. 4) Nobody is censoring content, nor taking part of the profits, on the web. 5) Everyone can create mobile web content without needing third party approval. 6) Your mobile website can easily become an app for mobile platforms.

Mail2voice is a mail management software dedicated to people with cognitive disabilities or illiteracy, to elder people or young children. Mail2Voice uses a simplified graphical interface which permits to use a touch screen. Outgoing messages are handled through audio recording, incoming messages are read by a speech synthesis, and address book contacts are reachable through a photo.

15 minutes? Be prepared to get a full 45 min. talk into 15 minutes! \o/

• What is Docker (Container Virtualization)
• How to use Docker (new way to think infrastructure)
• How to use Docker with MySQL.
• Run Docker in production?
• Why does Galera not fit into Docker.
• Why Galera should fit into Docker.
• Making Docker and Galera fit.

Do you really expect a full description for a 15 minute talk?

erkan :)

Technology change has created an inflection point for geodata. Mobile devices, social media, retail transactions, and more generate a tremendous amount of data. The volume, variety, and velocity of data is ever increasing. What do we do about it?

Technology change has created an inflection point for geodata. Mobile devices, social media, retail transactions, and more generate a tremendous amount of data. The volume, variety, and velocity of data is increasing. New technologies are being developed to handle the huge amounts of data. The problem is more complex than simply having a big relational database. This talk will present an overview of open source geospatial technologies which enable big geodata on the server and little geodata on devices and other clients to make it useful with the right context at the right time. More than technology for technology's sake, use it to do something meaningful.

Using LLVM on a new CPU or a new platform may require changes to the internal assembler. A common use case is the support of new instructions for a new CPU. In this talk I show how to add a complete new CPU feature, using the MIPS Octeon variant as an example.

LLVM has an integrated assembler in the MC layer. If a CPU vendor adds new instructions then it is necessary to extend the instruction description in order to use the new instructions at least in inline assembly. It would be even better if these instructions are also considered by the code generation. In this talk I show how to add a new CPU feature, new instructions and instruction aliases. I also demonstrate how the new instructions are selected by the code generation. As example I use the Octeon instructions which I added to the MIPS backend for the LLVM 3.5 release.

Community builders need data to measure growth, track volunteer contributions and measure success. Over the past year we have been pioneering the way we gather data about participation in Mozilla by defining contribution types, crafting pathways, building large scale systems, and publishing data. In this talk we will be giving the overview of the efforts so far and the way forward.

systemd is now a core component of most major distributions. In this talk I want to give an overview over everything new in the systemd project over the last year, and what to expect over the next year.

Runtime metaprogramming enables many useful applications and is widely used in frameworks, middleware, and domain-specific languages to simplify the task of application developers. However, today’s language implementations rarely optimize even common concepts such as reflective method invocation or dynamic proxies, despite the fact that solutions for efficient implementations have been advocated since decades.

In this presentation, we demonstrate how self-optimizing interpreters can be used to implement runtime metaprogramming efficiently. For the implementation, we use SOM Smalltalk, a little Smalltalk implemented in RPython (think PyPy) as well as Truffle (with Graal on top of the JVM). We show that both platforms can remove the runtime overhead of reflection and thus open up new opportunities for metaprogramming in performance critical scenarios.

A panel discussion covering subjects related to analog circuit simulation tools. Future Verilog-A efforts will be covered. Panel members include all speakers from the analog simulation session immediately preceding the panel discussion.

Connectivity is crucial for Internet of Things concept. For moving devices like position data loggers is typical solution GSM network. I will show you how you can use different types of GSM network for your IoT projects.

GSM network is easy way how to connect almost any device to internet. There are lot of GSM modules on market from different vendors but all devices has one thing in common - AT commands. There is standardized AT commands set for GSM networks. Using AT command you can send text messages, read phone number from list on SIM card, connect to internet and much more. I will show you basic command set for HTTP communication using basic GSM module SIM900 and Arduino.

This is an update on the first talk about QtCreator for embedded devices. There will be an short overview and then the presentation of the improvements from the last year:

QtCreator is the IDE of the Qt-Project. While the main focus is C++ based Qt development it has all usefull features for editing and navigation through large codebases. Like a code model for refactoring and autocompletion. As a lot of embedded development is done in C/C++ the only part missing for small µController support has been filled by the baremetal plugin for QtCreator. This enables QtCreator to talk to hardware debuggers with support for the gdb protocol. OpenOCD is a main development focus and it has now gained support for pipelining mode.

Besides giving an short overview over QtCreator the improvments made for embedded development will be shown. Fast Restart - issues a hardware reset right away without reflashing OpenOCD pipelining support - one click debugging *CMake build support (hopefully)

It is not so obvious to newcomers to the Hurd project how to follow execution path from their application to actual behavior in the Hurd translators. This talk will guide them through the involved RPCs, thus providing a starting guide into the GNU Hurd architecture, and hopefully, to contributing fixes or new features!

With monolithic kernels, the path from application source code to actual implementation in the kernel is very simple: only the system call layer needs to be understood. In a multiserver system such as the GNU Hurd, this is not so simple, since one for a start has to understand which server one is actually talking to, and how RPCs work. Once this is cleared up, it becomes way easier to know where to contribute fixes and features!

This talk will thus take a few examples of typical application operations (opening and reading a file, opening and working with a socket) and go through the RPC path, to illustrate how translators are involved and where the eventual implementations actually reside.

It will also be an opportunity to give the latest news about the GNU/Hurd project.

Many NoSQL databases come with a focus on performance, availability and scalability, sacrificing strong consistency guarantees along the way. In effect, this shifts the burden of providing consistency to the application, and often results in complex and error-prone application logic. Just a few years ago, an intense effort by Google resulted in Spanner - a globally distributed, replicated datastore that puts transactions back where they belong: right into the heart of the database.

CockroachDB is a grass-roots effort to bring to the table the guarantees of Spanner (and more) in an open source scalable database that is easy to deploy and, despite the name, quite attractive to have around. In the talk, I'll introduce you to the team behind CockroachDB and the current state of the art, briefly discuss consistency & Spanner and then dive into a tour of what's under the hood.

There are various cognitive radio models in literature which enable unlicensed users to exploit under-utilized licensed spectrum. This talk will explain the spectrum exploitation problem, some insight to the state of the art solutions keeping SDR implementations in mind. The presentation will also cover some of the practical interference learning schemes and how they can be used in these spectrum sharing scenarios.

Rocket is a simple daemon-free tool that enables users to run containerized apps on their systems free of host dependencies. Containers running under rocket execute like regular processes and can be managed using existing process management tools like upstart, systemd, runit, and etc.

Rocket is also an implementation of the "App Container Spec" which defines how to define and build containerized applications based on tooling like tar and pgp. And then host these files easily using standard protocols like HTTP. The goal of the spec is to enable independent and creative implementations of container runtimes and build tools.

Both of these projects are open source and part of a young growing community. Come learn how they work and how you can get involved.

Agora Voting is an open source voting software that allows any organization to carry out secure, flexible, transparent and cost-effective electoral processes. It has been used in multiple high profile elections in Spain, first in Congreso Transparente in 2013 by a congressman, then by multiple political parties (including leading ones like Podemos) to do internal binding elections, counting more than 400k votes in 2014. This year we moved to work on it full time, and we're expanding world-wide. Our aim: to be the reference secure open source voting project worldwide.

Design is not simply skin deep, it interacts with deeper layers in software programs. And it is not just for people who point and click to use applications. It also affects people who cannot distinguish certain colours, who cannot use a mouse, who are confused by complex user interfaces, etc. What can designers and developers in open source projects do to make their software more accessible? What do they need to know about people with disabilities? What tools are available to help them? What are example projects that have worked to improve accessibility?

In our ecosystem, we have the commercial MySQL Enterprise PAM/Active Directory plugins (which are not the focus of this talk). But we also have the PAM authentication plugin, two versions by Percona and MariaDB - find out what's different and how to use them including connecting against an LDAP service.

New in MariaDB 10.1 (and to be backported to 5.5, 10.0 too) will be the Kerberos authentication plugin that will also be able to work with MySQL/Percona Server.

Quickly learn how to integrate PAM and Kerberos plugins into your workflow.

Usually we talk about CI as a process. We can start from very simple "checkout, build, test and deploy" idea and we might come to some complex scheme of interconnected tasks or jobs with different pipelines fulfilling certain requirements, but we mostly remain within the process scope dealing with problems like what to automate, how to automate and in which order to run those automated tasks.

However in this talk we are going to step back a bit and look at CI as an infrastructure, i.e. the system of services, which is constantly evolving to catch up with changes happening in the base project. We will go through number of examples trying to figure out basic principles and common patterns of CI infrastructure, and discuss the ways to solve common problems arising from them.

To organize the discussion we will structure it in groups:

Services group includes topics like: - setup and update system, - message bus and status reports, - artifacts storage and distribution.

In Master group we put questions related to build system configuration, such as: - difference between interactive and non-interactive build systems, - proper use of templates for jobs configuration, - version control.

There are also Workflow questions like: - should people get access to debug failures in place and how to organize it? - how to test test?

As an extension for setup and update system topic we'll go through questions which deal with test environment, such as: - How to add new worker? - How to check it? - Will Docker containers solve all of our problems?

While this talk doesn't provide you with the recipe of the perfect CI, it could help you to prepare for the challenge which designing CI infrastructure definitely is.

GeoTrellis is a geospatial Scala library and framework for doing high performance geospatial processing in a distributed environment. This past year the developers of GeoTrellis have created extensions to the Apache Spark cluster computing platform to ingest and process raster data stored in Accumulo and HDFS. Spark and GeoTrellis can be used to process and serve raster data through web services to create TMS tile layers that can be used on web maps. The framework can work with both spatial-only tiles, as well as spatial-temporal tiles such as climate model data.

In this talk I'll describe the process of using GeoTrellis to ingest raster data into Accumulo, and give examples of how we can manipulate that data using spark. I will go into the architecture of the GeoTrellis core library, and how it leverages the powerful type system of Scala to make geospatial coding a lot easier. I will go into the architecture that has allowed us to geospatially enable the Apache Spark clustering engine, the difficulties we faced while working with the 3 libraries, and how we overcame those challenges. I will demonstrate working with both spatial-only and spatio-temporal raster data using the framework on an AWS cluster with Spark and Accumulo.

This talk describes the history, design, and implementation details of a number theory module for Perl. With implementations for most functions in C, C+GMP, and Perl this offers speed on most platforms as well as portability. Comparisons will be made with tools such as Pari/GP, SymPy, SAGE, Primo, OpenPFGW, and others.

The Perl ntheory module (aka Math::Prime::Util) offers a portable solution for many integer number theory tasks in Perl. While not offering the full feature set of robust and mature packages such as Pari/GP and SAGE, there are many areas where this package offers improvements.

With implementations in C, C+GMP, and Perl, there were a number of design choices made. We describe the choices and tradeoffs of making a package that is both portable, robust, and performant. Design choices for some algorithms (e.g. primality tests) are also discussed.

Highlights of this open source package include: - Fastest single threaded open source prime count and nthprime - Fastest 64-bit primality testing - Fastest bigint probable prime testing to 10k digits - Fastest nextprime, prev_prime - Fastest open source AKS primality proofs - Fastest open source ECPP primality proofs - Support for random primes and random proven primes - Ability to compile standalone C programs for tasks such as prime count, primality tests, primality proving, and primality certificate verification.

The random primes and primality testing/proving have been used in some new crypto modules, replacing older CPAN modules that were slower and had defects. The ECPP verifier written as part of this project is being used by FactorDB. In less than a year of use, simple Perl scripts using this module have been able to find over 37% of all current record prime gaps. Numerous defects in other open source packages have been identified during testing of this module.

Numerous applications in communication and multimedia domains show significant data-level parallelism (DLP). The amount of DLP varies between applications in the same domain or even within a single application. Most architectures support a single vector-, SIMD-width which may not be optimal. This may cause performance and energy inefficiency. We propose the use of multiple (heterogeneous) vector-widths to better serve applications with varying DLP. The SHAVE (Streaming Hybrid Architecture Vector Engine) VLIW vector processor is an example of such an architecture. SHAVE is a unique VLIW processor that provides hardware support for native 32-bit (short) and 128-bit (long) vector operations. Vector arithmetic unit (VAU) supports 128-bit vector arithmetic of 8/16/32 − bit integer and 16/32 − bit floating point types. Scalar arithmetic unit (SAU) supports 32-bit vector arithmetic of 8/16 − bit integer and 16 − bit floating point types.

The moviCompile compiler is an LLVM based commercial compiler targeting code generation for SHAVE processor family. The moviCompile compiler is capable of SIMD code generation for 128-bit (long) and 64-bit vector operations. This work focuses on compiler backend support for 32-bit (short) vector operations. More specifically, this work aims to generate SIMD code for short vector types (e.g. 4 x i8, 2 x i16, 2 x f16) that can be executed on 32-bit SAU next to the 128/64-bit SIMD code. As a result, moviCompile is able to generate heterogeneous assembly code consisting of both short and long vector SIMD operations.

This talk will give an overview over the Linux backports project and how to use it. The Linux backports project makes it possible to use a driver from a recent Linux mainline kernel with an older kernel version.

When you have a vendor board support package which does not use a bleeding edge mainline kernel, like it is the case most times, but you want to use some driver from a bleeding edge Linux kernel you can use backports. Backports "automatically" generates a tar with many drivers from a specific Linux mainline kernel which can be used with older kernel versions.

In this talk I will describe how the backports project, with its compatibility layer, the spatches and the normal patches. For practical usage I will show how to use backports with your own kernel in addition I will give a brief overview on how to add a new driver to backports.

As one of the earliest adopters of Method Handles, I've had to build many of my own tools. InvokeBinder is one of them, providing a literal (or fluent) API for Method Handles that allows site-forward adaptation, name-based argument list manipulation, and many bonuses usually too complicated to write by hand. I'd like to demonstrate its features and enlist others to help me improve it.

Short presentation of GHDL, followed by a discussion.

GHDL is a libre VHDL simulator. It compiles a design using the gcc or llvm backend. GHDL fully implements VHDL-87, VHDL-93, VHDL-02 and partially VHDL-08.

libmraa is a low level IO library for GNU/Linux platforms in the IoT sector. It tries to abstract platform 'crazyness' such as level shifters, i2c gpio expanders and other hardware features that software engineers don't want to deal with. It supports C/C++/python & nodejs and a number of hardware platforms.

I plan to run the talk in this order: - Small demo showing how to use IO on a MIPS based vocore & an intel based edison both using libmraa, a few sensors & actuators on various buses to show the flexibility and the same code running on both platforms - Example of why current APIs are too complicated and not portable - Quick walkthrough of the board configuration API to add new platforms to the build system - Q&A

The aim is to show people how we can interact with IO as seemlessly as possible between platforms and that adding new platforms to the framework is relatively easy.

A brief overview of Kodi (XBMC) open source Media center. How one of the oldest and largest open source projects originated, the path walked to present day and what the future might hold. Talk will include a brief history overview, what steps were taking to come in current state and what our goals are for the future.

It's relatively rare and difficult to keep a large scale open source project going year after year without the firm financial backing of a larger organization. Since its inception in 2002, the software currently called Kodi has gone through numerous changes, both at the software level and at the organizational level, and has encountered numerous difficulties along the way, from simple communications problems both internally and with the userbase to larger organizational snafus. In this talk, we'll review how the organization has managed to overcome these problems and continue on.

Topics expected to be covered will include a look at the platforms, distributions, and hardware supported today; a review of the history on the Xbox, the switch to platform agnosticism, and the creation of the Foundation; and plans for the future.

Additionally, an overview of how the organization works and software is developed currently will be presented, along with a look at who uses Kodi, both from a user perspective and a business perspective.

How do you support a diverse community, acknowledge many different voices and perspectives, be open and inclusive, and still get things done (especially when you can’t force anyone to do anything)? What motivates people to not only start contributing to a project but to continue to contribute? Why on earth would anyone, including developers, do work they are not paid for? In this session, I’ll share what I’ve learned (and keep learning) by working with, in, and for volunteer communities; including how to be more transparent, create opportunity, and broadly share ownership.

The Mozilla Developer Network is an open-source documentation wiki for web developers, which is written by really passionate, smart, and inspiring people. Most are not paid employees of Mozilla. All of them are helping make the web a better place by coding, writing, and reviewing articles.

How do you support a diverse community, acknowledge many different voices and perspectives, be open and inclusive, and still get things done (especially when you can’t force anyone to do anything)? What motivates people to not only start contributing to a project but to continue to contribute? Why on earth would anyone, including developers, do work they are not paid for? In this session, I’ll share what I’ve learned (and keep learning) by working with, in, and for volunteer communities; including how to be more transparent, create opportunity, and broadly share ownership.

Time is the most precisely measured quantity we have, yet it is still the most mysterious. Precise time and frequency are the hidden ingredient in most technology used today, from computer synchronization, to satellite navigation, to data communications, to digital music and video. In this talk we explore the amazing world of precise time, a world that anyone with curiosity can explore on their own.

It is not uncommon for ham radio operators, electrical engineers, or physicists to encounter the details about precision timing. But it turns out that playing with computer hardware and operating system software is also a wonderful entry into the obscure world of nanoseconds and parts per million accuracy.

The talk is in three parts:

• Examples of precise time and frequency in computing, from operating systems to microcontrollers.
• A "powers of ten" tour of clocks, timekeeping, and measurement; from the worst possible clock you can find at home to the best atomic clock you can buy.
• The results of Project GRE²AT, a DIY time experiment where Einstein's general theory of relativity was demonstrated by carrying atomic clocks from home up a mountain and the predicted time dilation actually measured. This puts keeping accurate time on a new level, and makes one wonder what time really is.

One of the key component in many GnuRadio projects is the quadrature frequency demodulator. This functionality allows to calculate the real analog output of a frequency modulated signal from the IQ-signal, which is mainly captured using HF hardware (e.g. dvb-t dongle, USRP, etc.) by a carrier frequency (band pass domain) and transform it to the base band domain. The most known implementations of the FM-demodulator are based on trigonometric functions. These functions require a high computation effort. Some implementation of “tuned” trigonometric function, which were downsized for FM-demodulation reduce the computation effort a little. A new proposal of a so called arithmetic FM-Demodulator allows to avoid completely the usage of any trigonometric function and speed up the computation process in many times. In the presentation I will introduce mathematical background for the arithmetic FM-Demodulator, show the differences and limitations to the current implementation in GnuRadio Version. Further Philipp will present our result, we had achieved in our lab.

Most provisions against the steadily growing threats imposed by malware, viruses, and directed attacks are fighting symptoms rather than addressing the root of the problem, which lies in the operating system. Genode is an open-source OS technology that promises to give an answer to those threats. By organizing the system as nested sandboxes and consequently applying the principle of least privilege, it protects the privacy of the user and renders most classes of malware ineffective. The talk will be presented on a Genode-based system, which allows the demonstration of the concepts live during the talk.

The effects of malware and client-side attacks seem to have become a prevalent part of our inter-connected world and increasingly affect individuals, businesses, and governmental institutions alike. The topic has even managed to capture the attention of main-stream media, prompting vocal calls for counter-measures. Governments invest large sums in forming cyber-defense departments. Computer users are urged to invest money in anti-virus software and install a steady stream of security updates. However, those actions are just reactive, fighting symptoms, and merely relieve the problem rather than solving it. For example, none of those measures is effective against zero-day exploits.

The root of the problem is not the "dumb user", or "outdated anti-virus software", or "cyber terrorists" but the antiquated way of how today's operating systems are structured, how they implement security, and the chaotic way of how software components are allowed to interact with each other.

Genode is an 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. Furthermore, programs are able to communicate and trade their resources, but only in a well-defined manner. Thanks to this rigid regime, the attack surface of security-critical functions can be reduced by orders of magnitude compared to contemporary operating systems.

This sounds pretty academic but there exists an Open-Source implementation in the form of the Genode OS Framework showing that those ideas translate to a general-purpose OS. In line with Unix philosophy, this framework is a collection of small building blocks, out of which complex systems can be composed. But unlike Unix, those building blocks include not only applications but all classical OS functionalities including kernels, device drivers, file systems, and protocol stacks.

During the talk, we will see several of those compositions demonstrated, hinting at the vast flexibility the architecture provides. At present, this makes Genode a rich playground for OS enthusiasts. The ultimate goal, however, is a fully-fledged operating system that protects the user's privacy and data, and relieves us from worrying about malware, virus infections, and directed attacks. The talk will show how Genode renders various classes of malware pointless and how the Genode developers envision their migration path from current-generation OSes to Genode.

Most web developers focus on writing code. But creating web applications is about much more than just writing code. Take a step outside the code cocoon and into the big web ecosphere to find out how small code changes can make a world of difference on servers and network. This talk is an eye-opener for developers who spend over 80% of their time coding, debugging and testing.

Atomic mode-setting has been discussed and designed for literally years. Now it's finally there. Most of the prerequisites have been merged into the mainline kernel. The first drivers are being converted and the final versions of the user-space IOCTL are being drafted. With it come all sorts of new, exciting features. But there are also confusing aspects to it.

This talk will give a brief history of how kernel mode-setting (KMS) evolved, explain some of the shortcomings of the current KMS API and how atomic mode-setting will make everything better.

The focus of the talk will be on how to convert existing kernel drivers to support atomic mode-setting based on lessons learned from going through the conversion of the Tegra DRM driver.

Phabricator is an open source software development platform used for project management, bug reporting, and code review in an integrated fashion. Wikimedia has about 500 regular contributors developing MediaWiki plus hundreds of extensions and related tools. We are deploying https://phabricator.wikimedia.org to replace Bugzilla, RT, Trello, Mingle, Gerrit, gitblit, and Jenkins. This is the biggest and most complex Phabricator migration we are aware of, and we want to share our first-hand experiences with other free software projects.

Why such a big change? All the tools we are/were using kind of work/ed. However, we felt that the cocktail of tools was slowing us down, becoming also an obstacle for new contributors. In more detail:

• The volume and complexity of our software projects keeps increasing; MediaWiki and Bugzilla fall short for project management.
• Wikimedia Foundation teams were increasingly using Mingle and Trello, 3rd party commercial services that are alien to the Wikimedia community and principles. This was creating a divide. Wikimedia Germany was trying Scrumbugz, a one-man OSS project barely maintained.
• Overlap, duplication, and actions falling between the cracks increased.
• To mitigate this problem, we created more tools to synchronize information between services (like "Bingle", "Bugello" or Gerrit notifications in Bugzilla). They needed to be maintained (i.e. when one service is upgraded and its API interface has changed).
• Contributing to Bugzilla (Perl) and Gerrit (Java) is complex for us (PHP, and Phabricator is written in PHP), while there is no way to contribute code to proprietary Mingle and Trello.
• The current setup brings overhead and annoyance to key developers: Senior developers having to use heavily Gerrit, Bugzilla, and Mingle/Trello. New contributors, most of them arriving with GitHub-like expectations.

As we write these lines, this is an ongoing work. Learn more about the Wikimedia Phabricator timeline and other project details at https://www.mediawiki.org/wiki/Phabricator

Data is everywhere. User comments, preferences, online games features, all that small chunks of information which clients need to communicate with its servers use JSON format now. This format can be read into an object using parser built-in in all modern clients. But what about server side? What about information which should be stored for future use? Do you still need to manually parse JSON data to be able to effectively search through? Do you still need to spend time retrieving documents, load parse library and process? Not anymore! In this session I will present set of functions which manipulate with data in JSON format inside MySQL server. These functions search, modify and validate JSON data for you.

JSON UDFs is a set of UDF functions which perform queries using JSON language. This MySQL Labs project available at http://labs.mysql.com/ Further information about JSON UDF functions exists on author's blog at https://blogs.oracle.com/svetasmirnova/tags/json

I presented first public version of functions last year. Since than 3 minor and 1 major releases of the functions were provided. I hardly worked on feature requests, sent by the users, implemented 4 new functions, accepted 1 contribution. In this session I will tell about the functions: what do they do, how to install them, will say few words about future plans.

A short talk about GeoTrellis and the GeoTiff File Format. I was a Google Summer of Code student at GeoTrellis and implemented a GeoTiff reader for the project. I will present what GeoTrellis is, how I implemented the GeoTiff reader and talk a bit about the GeoTiff File Format and which compressions that are associated with it.

Brad Fitzpatrick gives an overview of HTTP/2 (its design and advantages) and then discusses the design of Go's http2 package.

In our interconnected world of mobile and cloud computing, particularly with the rise of governmental spying, corporate espionage, and theft of data by organized crime syndicates, security is more important than ever. Many claims are being made about the security of open-source cloud technologies: How can administrators, users, and developers separate fact from fiction?

This talk will equip the audience with the principles needed to evaluate security claims. We will talk the nature of risk, of vulnerabilities and exploits; the various factors that reduce the risk of vulnerabilities in software; and about TCB, threat models, and defense-in-depth. And we will introduce a colorful and (hopefully) helpful analogy to help make these concepts more clear.

We will then apply these principles to three open-source cloud technologies: containers, KVM, and Xen, to see how they stack up. These will be backed up with numbers: lines of code, security advisories, entry points, and so on.

Audience

This is particularly aimed at system administrators or system architects wishing to make decisions about which cloud technologies to use or deploy. It should also be of interest to those who want an introduction to thinking about security analysis in general.

Benefits to the ecosystem

First, it will help those making decisions about which technology to used to make an informed decision. Secondly, by giving the audience a framework for thinking about security analysis, and show how to apply it to some concrete examples, it will help anyone thinking about security in almost any area of development or configuration.

KSP Tools is a set of tools to simplify and automate the tasks that are needed to attend a key signing party. They will significantly reduce the amount of work needed, and reduce the amount of errors that can be made. My aim is to reduce the amount of work to be done before and after the meeting to just 5 minutes, even with the large amount of people that attend the event at FOSDEM (~100 people), without compromising security.

I also hope to considerably shorten the amount of time that a key signing party takes through future work.

The current tools are:

• ksp-makelist: Generates a better formatted key list for usage at a key signing party. It's better looking, more readable, more comfortable to use and can be processed automatically by scanning QR codes.
• ksp-scanlist: Makes a list of keys to sign by scanning QR codes from the above list.
• ksp-list: Performs operations on a list of selected keys like signing keys and mailing them.
• ksp-import-keys: Connects to a mail server and automatically imports signatures people emailed to you.

The tools automatically check fingerprints and use a file format that is easy to handle with standard tools like grep and awk.

These tools were made after my experience with key signing parties at FOSDEM and I hope other people will find them useful.

After attending several key signing parties at FOSDEM I found that with a large number of participants it's a process that can take hours to finish the meeting, and a large amount of time afterwards to deal with the results. It's easy to make mistakes that make people waste their time, or that compromise security.

Since PGP signatures are widely used in Free Software development (for instance for signing packages), it's important to make the process as reliable as possible.

Signatures are also important for end users. Important packages like GPG or Tor are signed. The easier it is to participate in a key signing party, the more people will attend and will be able to know they got a good copy.

The tools are written in simple, clear code and follow the UNIX philosophy, making it easy to customize the process to your needs.

Forward Error Correction (FEC) is a vital part of every communication scheme. Convolutional Error Codes can provide the protection of the data to drive the communication system close to the Shannon Limit. But due to the complexity of the decoders, it is challenging to implement these algorithms in software for use in software defined radios (SDR). Available coprocessors, such as graphic processor units (GPU) and single instruction multiple data architectures (SIMD) can dramatically enhance the throughput of such software based receivers. Strategies to start implementing Viterbi- and Maximum A Posteriori (MAP) Decoders on these coprocessors are presented in this talk. Potential tripping hazards are identified. The effects on the throughput of these algorithms are analyzed and shown.

Convolutional Codes have been known for a long time. Viterbi established his algorithm to decode convolutional encoded data in the year 1967 [1]. SDR has also been established since the late 90’s and early 00’s. But still the implementation of convolutional decoders, such as the Viterbi- or MAP-algorithm, in software has always been a problem. Both algorithms rely on a Hidden Markoff Model as the encoder is simply a Mealy Machine. So if one surveys every possible state transition caused by a bit stream, a trellis structure is created. For every encoded information bit you have to consider all possible transitions from one state to another [1][2]. This leads to a high complexity and implementations of these algorithms suffer from a heavy computational burden.

The Viterbi Algorithm tries to relax these conditions by applying a dynamic programming approach to the trellis structure [3]. In this approach only the strongest path survives to reduce the overhead generated by analyzing all possible paths through the trellis. Still the computational effort is very high.

Up until now the technology used in SDRs has not been able to handle the computational burden of these algorithms. Implementations generally have suffered from a low throughput that was not suitable for state of the art communication systems (i.e. 3GPPP LTE or WLAN). Therefor these systems still used fixed hardware chips, such as ASICs, to manage the high throughput that these systems require.

With the increasing clock rates of General Purpose Processors (GPP) and the higher density of units inside the architecture, implementing these algorithms is starting to become more feasible. Especially additional architectural features such as SIMD architectures and multiple processor cores on one chip have gained increasing importance when implementing digital signal processing algorithms in software [4].

Another interesting field is the use of coprocessors found in common computers. In most cases this is going to be a GPU. GPU vendors also provide libraries and software development kits (SDK) to use the GPU for general computations and signal processing [5]. This specialized processors and libraries can be efficiently used to accelerate algorithms that can be massively parallelized.

This talk will cover implementation constraints that occur when implementing FEC and DSP algorithms on SIMD processors and GPUs. It will highlight some of the tripping hazard that newcomers have to avoid when trying to make an efficient use of these coprocessors. Exemplary cases for both architectures are analyzed to show, how the proper use of these architectures enhances a software defined communication system.

REFERENCES [1] A. Viterbi, “Error bounds for convolutional codes and an asymptotically optimum decoding algorithm,” Information Theory, IEEE Transactions on, vol. 13, no. 2, pp. 260–269, April 1967.

[2] L. Hanzo, T. H. Liew, and B. L. Yeap, Turbo Coding, Turbo Equalisation and Space-Time Coding for Transmission over Wireless Channels. Wiley, 2002.

[3] J. Forney, G.D., “The viterbi algorithm,” Proceedings of the IEEE, vol. 61, no. 3, pp. 268–278, March 1973.

[4] U. Santoni and T. Long, Signal Processing on Intel Architecture: Performance Analysis using Intel Performance Primitives, [Online]. Available: http://www.intel.com/content/dam/doc/whitepaper/ signal-processing-on-intel-architecture.pdf, 2014.

[5]NVIDIA: OpenCL Programming Guide for the CUDA Architecture, 2009. Version 2.3.

Garbage Collection pauses make it hard for Java applications to meet quality of service guarantees. No matter how fast your application processes requests, a 30 second GC pause is going to ruin any guarantees you might want to make.

Shenandoah is a new GC algorithm designed to address this issue. We take a simple approach that allows us to do more work while your Java program is running so we can substantially reduce the time the JVM is paused. Our goal is to be able to garbage collect 100gb+ heaps in under 10ms.

This talk will focus on the current status of the project, the goals we've met so far, and what we are hoping to achieve in the coming year. We might even share some performance numbers.

Disk encryption is essential for physical computer security, but seldom used due to the trouble of remembering and typing a password at every restart. We describe Mandos, a program which solves this problem, its security model, and the underlying concepts of its design.

Any security system must have a clear view of its intended threat model – i.e. what threats it is actually intended to protect against; the specific choices and tradeoffs made for Mandos will be explained. Another danger of security system design is the risk of its non-use; i.e. that the system will not be used for some real or perceived drawbacks, such as complexity. The deliberate design choices of Mandos, involving low-interaction, “invisible” and automatic features, will be covered.

The multi-user support is a new feature of Tizen 3 which aims to enable multiple profile in connected devices while enabling a strict application containment. This new feature responds to a secured multi-seat context as Tizen IVI (In-Vehicle Infotainment) project.

The multi-user mode is a new feature of Tizen 3 that mainly impacts the application framework, resources management and security framework. The aim of multi-user Tizen 3 support is to enable multiple profile in connected devices while enabling a strict application containment.

We will see how this new feature allows a new way to manage applications, services and HW resources in a secured multi-seat context, thus meeting Tizen In-Vehicle Infotainment (IVI) project needs; We will discover the concepts of a default user before connecting, of separated connected users and privilege user and how users can exchange seats without lost their applications context.

Patchwork is a toolkit for connecting various devices into a network of things or, in a more broad case - Internet of Things (IoT). The main goal of creating this toolkit is to have a lightweight set of components that can help to quickly integrate different devices (i.e. Arduinos, RaspberryPI's, Plugwise, etc) into a smart environment and expose specific devices' capabilities as RESTful/SOAP/CoAP/MQTT/etc services and data streams.

The key features of patchwork include:

• Lightweight (no RAM-consuming sliced pie of Java and OSGi, only bare necessities)
• Cross-platform (can be deployed on OSX/Linux/Windows, tested on RaspberryPI and BeagleBone Black boards)
• Language-agnostic (device agents can be written in any programming language, APIs can be consumed by app written in any programming language)
• Easily deployable (no JARs, no Eggs or Wheels for the core components, just a single native binary with statically linked dependencies)
• Easily extendable (integrate new devices without modification of the core components, drop in solution)
• Interchangeable (not happy with current existing Device Gateway or Catalog? replace it with another implementation without breaking the infrastructure)
• Not re-inventing the wheel (we re-use as many existing technologies and components as possible)

How to get started bringing user experience design practices into open source projects using Drupal as a case study.

If you want to grow the user base of your open source project, or even just want to make things simpler for your existing users, then one of the ways you can do that is by making your app easier to use. Topics that we'll discuss:

• Ways to make the case for the need of a good user experience
• How to get started making good design part of your project
• About the challenges of designing in open source
• How to foster collaboration between designer and developer
• What you can do to attract (more) designers to your project

Since 2007 there has been a dedicated ux design team working on improving the usability and design of the Drupal content management system. Roy Scholten has been part of this effort since its beginning.

In this hands-on presentation, Marco will demonstrate how to use the screen reader built into Firefox OS and other tools to help create more usable, more accessible web applications. Such applications have a much better chance of reaching a broader audience. In addition, they will help developers to write more semantic and more maintainable code.

About 20% of the population world-wide have a disability. Disabilities include blindness or visual impairment, deaf or hard of hearing, people with motor impairments, people with dyslexia, and others. For years, there have been assistive technologies such as screen readers for the blind, magnifiers for visually impaired, subtitles or sign language captionings for videos, switches or other assistive devices for people with motor impairments, and many more to help those 20 % come onto the web and participate just as their non-disabled friends and family members do.

In addition, the demographic development suggests that by the year 2030, half the population in Europe, the U.S. and Canada will be age 60 and older. Those commonly called "silver surfers" will also benefit from bigger touch targets, better contrast and other usability techniques traditionally associated with accessibility, even when they do not have any disability themselves at all.

As mobile devices spread throughout the world, and Firefox OS sets new standards in affordability and availability in many countries that did not have access to smartphones before, it is more and more important that web applications offered on those devices are usable by the broadest range of users possible.

This presentation aims to provide some basic easy checks and testing techniques to help you as a developer of a mobile web application to apply good programming practices so your app can reach more users than you ever thought possible. Marco will show how you can use a Firefox OS device and Firefox itself to do these easy checks and take good techniques home to put to use straight away.

Fedora 21 marked the first phase of the Fedora.next Initiative, an umbrella concept for a reimagining of how Fedora will operate in its second decade. This talk will focus on the switch to a Product-based model, the reasons behind it and the challenges (both technical and social) that we faced in shipping Fedora 21.

The session will be broken into approximately 25-30 minutes of lecture lightly covering a variety of topics including release-engineering, new feature development and socialization of ideas.

After the talk, the session will be opened up to a Q&A session with the audience.

Habitat is a proof of concept project to re-purpose Cucumber style tests to process data about your location. Implemented in Python using Celery, Behave and Flask.

After the nice blog post of Scott Noyes, I decided to dig a bit more on the topic of undelete rows from the binary log.

This is a more detailed 101 session that explain how to find all events to change and show how to deal with that using easy python commands.

We will also see how to un-insert and un-update events.

See https://github.com/lefred/MyUndelete

It also covers different version of MySQL, from 5.5 to 5.6 and MariaDB.

Have you ever wondered how simulators perform their tasks? Are you looking for a FOSS replacement for your proprietary simulator?

Icarus Verilog is a part of gEDA project. It is mostly known as a FOSS hardware description language simulator, although its capabilities reach beyond that. The name indicates it is a Verilog simulator, many features of SystemVerilog are already implemented and VHDL makes its way there.

If you want to hear about what else you can achieve with Icarus, how its internal gears are running, or possible ways to extend its functionality - feel invited.

C2 is a new programming language that been under development since 2011. It attempts to maintain the spirit of C, while considerable raising development speed. C2 also adds some greate features and tools to developers. This talk will zoom in on 'problems' in C, the solution chosen in C2 and the implementation on top of Clang/LLVM.

The C programming language has been around for a long time and is one of the main 'open-source' languages that is used today. The C2 project attempts to build on the success of C, while keeping the spirit of C intact. C2 doesn't change the abstraction level (like C++/Java/etc), but it does change the way code is structured . This will greatly accelerates development cycles and at the same time increase run-time speed as well. One major change is the removal of the use of #include's to access code in other files. The C2 language was first introduced at Fosdem '13.

Looking at the evolution of the Cloud everything started with centralized services. Today everybody can set up his own Cloud with Free Software. What's next? This talk will discuss the idea to connect this decentralized clouds in a way that users can share seamlessly data across multiple instances.

Looking at the evolution of the cloud, as a file share and sync solution, everything started with centralized services and evolved to to the point where everybody can set up his own Cloud with Free Software. Decentralizing the cloud was a important step but at the same time it created islands. Only user on the same instance can collaborate on the same files. The next step will be to connect this individual clouds to enable the users to collaborate seamlessly across multiple instances. The ownCloud project works actively on this idea, this talk will discuss the general idea behind it and how this is going to happen.

It’s not a bug, it’s an environment problem. Environments are costly and data refreshes tedious. As a result, QA analysts have to make compromises and work in environments that have a different makeup than the production environment, which can create false positives and missed bugs. This presentation will help QA engineers learn how to mitigate the lack of data refreshes by creating modular test cases and use parameters to dissociate the data from the test cases and automation and therefore be able to work with data that you do have in each environment. Additionally, it will dive into how to maximize the environments QA professionals currently have and align them to their testing process to do feature testing and regression efficiently.

Daybed is a reusable Web API providing validation and storage as a service. Define your schemas, their fields and permissions using JSON, and you obtain a dedicated RESTful endpoint! It has spatial fields support, GeoJSON output and ElasticSearch indexing!

Usually, when a Web application requires a spatial backend for storage and validation, a custom API is developed and deployed (reinvent the wheel).

But with Daybed, persistence is a service. It's a minimalist and generic REST API, built with python, on top of the storage backend of your choice, like Redis, CouchDB or ElasticSearch. You can host it yourself or use the one we run at https://daybed.io!

In this talk, we will present why Daybed is the perfect component for rapid application building, and how it can be used for collecting and storing geospatial data. A quick overview of its authentication and permissions system, and you will figure out you can turn any mobile app or static Web page into a collaborative application with no effort!

We will also introduce daybed.js, our tiny JavaScript wrapper, to visualize data or build collaborative webmapping with only a few lines of code!

SPAs are the new way to do web apps. Javascript is the de facto assembly language of the web,

But Javascript is ugly and debugging it is nightmarish (despite Developer Tools). Node is cool, but Javascript is not as much.

I will talk about the experimental work I've been doing to securely sandbox graphical applications in a Wayland based desktop. I will also talk about the next steps and how this work relates to the GNOME Safety project and systemd.

FPGA features and resources had dramatically increased in the last years. State-of-the-art devices are now too complex to be tackled by a single individual by using standard HDL tools.

The OHR community hosts and maintains a set of Free/Open high-level FPGA development tools that aims both to increase productivity and to empower resource and knowledge sharing.

This tutorial provides a short introduction & demo for two of the main HDL tools at OHR (HDLMake and Libre-FDATool) and finally introduces some of the hottest trends in high-level FPGA design tools.

This tutorial consist in three different blocks, one for each of the featured tools and a final one is left for conclusion and Q&A.

Featured Tools:

HDLMake:

Hdlmake generates multi-purpose makefiles for HDL projects management. It supports local and remote synthesis, simulation, fetching module dependencies from repositories, creating project for multiple FPGA toolchains... All of this can be done with a makefile command or with Hdlmake directly. It supports modularity, scalability, use of revision control systems and code reuse. Hdlmake is free, open and distributed under the GPL license.

Libre-FDATool:

Libre-FDATool is a Python package aimed at helping in the analysis and design of HDL filters from high-level specifications. This Free/Libre Open Source software supports both VHDL and Verilog code generation and relies on a collection of Free scientific and EDA tools for providing advanced features -- simulation, graphics, debugging, etc.

Conclusions / Beyond HLS:

• State-of-the-Art: new All-programmable SoCs, HLS (High-Level Synthesis) tools for FPGA, HW code accelerators...
• Operating System and HDL as a whole. The gateware part of an hybrid CPU+FPGA system can be handled by the Operating System just as a standard dynamic library. Proof of concept: "meta-spec", Yocto Project support for OHR SPEC (Simple PCI Express FMC Carrier).

This will show what is Hybrid Cryptography and how we can use Hybrid Cryptography in Restful environments.

I will show with example code in Ruby how this flexible system can be applied in Text, HTTP, and maybe other places to show how it is applicable to Restful systems without changing any current protocols.

Firstly, I will give an explanation of what Hybrid Cryptography is in theory, how it can work as an alternative cryptosystem or work with other cryptography. My aim is to show that the users of this method allow them to control which cryptographic algorithms are used and when key rollover is performed.

I will then highlight that as this is non-invasive, it can be used anywhere in the Internet protocols, maybe showing an example of working with another Internet protocol to show this.

Then, I will show simple examples. I show how it can be used in text, encrypting a text file. Then, I show an alternative to HTTPS using this to encrypt a web page. I then show that it can work with HTTPS pages too.

If given time, I will show where this came from in encrypting DNS NAPTRs.

Example code in Ruby will be shown throughout to allow others to use.

I do not believe this applies directly to the main themes. I am estimating that this talk is 30 mins, although I am busy coding, so have not drawn up the presentation slides.

We live in an age in which every person owns two or three devices that are powerful enough to render a few seconds of 3D movies in a while although they are used mainly to send messages via WhatsApp and create selfies for social network consumption. At the same time, all these devices have the closest thing to an universal virtual machine that has ever existed: the JavaScript virtual machined, paired to a (roughly) standard object model that allows anybody with a bit of programming prowess to create programs that can be run anywhere and everywhere. There is great potential for massive distributed computing in this environment, but the ability to tap it a bit farther than sending basic computations is not there yet. In this presentation we will talk about the issues involved in doing so, from basic algorithmic issues to twisted legal issues that can arise when you are using devices you don't own to perform unwitting computations.

Volunteer computing was started thanks to lack of funds and surplus of computing power (and connectivity to go with it) on the hands of labs and companies. Stealth computing was proposed initially by Barabasi to take advantage of devices connected to the network that perform very basic computations. There's a very fine line between them, a line that includes a button that says "Click here" or the will to not use resources more than those dutifully allotted by the operating system. There are also usability differences between volunteer and stealth computing and maybe ethical and legal ones. However, from the point of view of the computing model and the techniques involved, there is no difference. In this talk we will explore the possibilities of stealth/volunteer computing using mainly the browser and the issues involved with it. The main one is performance, either from the algorithmic point of view or CPU-cycles-wise. How many CPU cycles could be achievable using them? Is it predictable in a way? And there is an intriguing edge to the performance model: it includes the fact that there will be a big dependence on the web page that is used itself, from its content, to its search engine position, to the way it is announced in social networks and by whom. Even as there is some predictability in the whole experiment, from the algorithmic point of view it is impossible to know, in advance, how long a particular user is going to stay contributing to the system and when he's going to come and go. This is an issue that has to be leveraged in the algorithm so that these cycles contributed actually add something to the whole experiment and do not detract from it. We will specially talk about population-based algorithms, which are the ones we do have a certain experience with, but any algorithm that has some dependencies (that is, anything that goes beyond brute-force approach) will experience similar issues. Finally, there are some trust issues that must also be taken into account. There are purely legal issues, but stealthy volunteer (or voluntarily stealth) computing should follow open science best practices, since that is the only way of managing a healthy and sustainable meta-computing device where people or citizens have a huge role.

libcurl is the world's most used and most popular internet transfer library, already used in every imaginable sort of embedded device out there. How did this happen and how do you use libcurl to transfer data to or from your device?

Embedded devices are very often network connected these days. Network connected embedded devices often need to transfer data to and from them as clients, using one or more of the popular internet protocols.

libcurl is the world's most used and most popular internet transfer library, already used in every imaginable sort of embedded device out there. How did this happen and how do you use libcurl to transfer data to or from your device?

Daniel once founded the project and is still lead developer and maintainer of the curl project, making curl and libcurl. He is also active within IETF and maintain several other open source projects. Daniel is employed by Mozilla.

RFNoC (RF Network-on-Chip) is a framework that allows easy and rapid development of FPGA signal processing systems, with the same FPGA and host code to be used across multiple devices and applications.

Its general architecture will be presented first and then the current implementation state of a practical RFNoC block designed to accelerate RTSA-like (fosphor) spectrum visualization will be described.

Most people who work with computers have no idea how the computers keep time. All networked computer systems require some form of temporal synchronization. As networks have gotten faster the demands for accurate, distributed, timekeeping have increased, but most programmers have no idea about the quality of the clocks in their systems, nor how they might be kept in sync. This talk will go over the basics of computer clocks, why they're inaccurate, and what can be expected from various strategies for getting systems into sync.

All networked computer systems require some form of temporal synchronization. As networks have gotten faster the demands for accurate, distributed, timekeeping have increased, but most programmers have no idea about the quality of the clocks in their systems, nor how they might be kept in sync. Most programmers have at least heard of NTP (The Network Time Protocol) which is used to synchronize computer clocks over a network, but fewer have heard about more recent work, such as the Precision Time Protocol which can keep computers accurate to within several hundred nanoseconds when working over a LAN. Well synchronized clocks are used in financial applications such as High Frequency Trading as well as the electrical grid and cellular telephone networks.

This talk will cover:

• How computers keep track of the time, and how they fail miserably at this.
• The fundamental ideas behind network based time keeping, why we do it, and how it works.
• Network Time Protocols (NTP and PTP) deployment, use and tuning.

Firefox for Android aims to give users control of their privacy on the mobile web. In addition to many built-in privacy features, Firefox also supports add-ons, which can give users even more privacy options. In this session, I'll talk about different privacy features that we've been adding to the browser, highlight a few privacy add-ons that are available, and demonstrate how easy it is to create new add-ons yourself.

A detailed walk through the analysis of a deadlock in the HelenOS filesystem layer involving IPC communication and spread across four server processes. The talk will focus on demonstrating how a problem like this can be root caused from within the same running HelenOS instance that was affected by it, relying solely on its own observability features.

Successful, tech-related, consumer-oriented companies with "hockey stick" growth -- companies like Twitter, Netflix, Spotify, and SoundCloud -- represent what might be called the "modern enterprise".

These organizations run microservice architectures which are continuously built and deployed, deeply instrumented, data-driven, and can fundamentally change from day to day. The open-source software stacks they use gain recognition, contributors, and momentum.

Go has many advantages in this kind of environment, and seems well-posed for becoming its de facto language. But we're definitely not there yet.

This talk is an experience report of Go in the "modern enterprise" of SoundCloud, and my opinion of what needs to happen with the language and ecosystem for it to gain real mindshare in that environment.

Replication is used everywhere with MySQL. But applying writes in a single thread is often a bottleneck: replicas have a hard time keeping up with the master that can execute writes in parallel. Enter MySQL 5.6 and you can use several threads to apply writes on replicas as long as you have several schemas. MySQL 5.7 goes even further: by introducing a logical clock and by changing the scheduling logic, you can apply writes in parallel in a single schema.

Come to this session to learn all you need to be comfortable with multi-threaded replication.

Replication is used everywhere with MySQL. But applying writes in a single thread is often a bottleneck: replicas have a hard time keeping up with the master that can execute writes in parallel. Enter MySQL 5.6 and you can use several threads to apply writes on replicas as long as you have several schemas. MySQL 5.7 goes even further: by introducing a logical clock and by changing the scheduling logic, you can apply writes in parallel in a single schema.

The result is of course a much better replication throughput, but this feature also raises a lot of questions: - How does it work internally? - Does it play well with GTIDs? - How can you monitor replication status? - How do you recover from a replication error? - If you want to take a backup from a replica, how can you make sure you will get a consistent snapshot?

Come to this session to learn all you need to be comfortable with multi-threaded replication.