FOSDEM welcome and opening talk.

Welcome to FOSDEM 2017!

Kubernetes enables teams to focus on developing innovative applications by simplifying deployment, scaling, and configuration through a simple yet flexible API. The system can support all types of applications: web apps, databases, distributed systems, or even VMs; and can do it on any cloud or bare-metal platform. Our vision is that every organization has access to this infrastructure technology, a mission we call #GIFEE: Google Infrastructure For Everyone.

But, as Kubernetes’s reach grows, what do real production applications look like? Where does Kubernetes need to go to continue supporting an ever-wider range?

Join Brandon Philips for a look at the status of Kubernetes and at the roadmap for its future, including automated Kubernetes upgrades, management of complex applications, integration with cloud providers, and multi-cluster federation.

Welcome to the Software Defined Radio track! As in the last couple of years, we will talk about anything related to software defined radio: Interesting hacks, SDR hardware, wireless security, homebrew radar, academical research, etc. Here, we introduce the track and topics, and welcome all fans and afficionados of the SDR track!

The software defined radio track has been part of FOSDEM since 2014, and has been choc-a-block with talks an all kinds of topics related to software defined radio. This year again, we'll be talking about a variety of topics ranging from interesting hacks to SDR hardware, wireless security, homebrew radar, academical research and many other things that fall into this wide field.

Welcome and opening session

An introduction to graph databases. From graph theory, through the history of computing and how it affected database design, to why relational databases aren't about relations. Next, a look how diverse is the current graph database market and what obvious and not so obvious problems are solved by graphs. A short introduction to Neo4j's query language, Cypher, will show the main concepts of querying graph data. Then, by use of the same datasets in both relational and graph databases will compare syntax clarity and database performance.

A short introduction of the devroom and some warm words.

Memcheck is probably the most heavily used tool in the Valgrind suite, checking for invalid addresses, undefined values and memory leaks. In this talk I'll look back at the history of the tool, then I'll look forwards at some of the challenges it faces as the hardware and software ecosystem continue to evolve around it. I'll talk a bit about some of the effects of Memcheck on the C++ ecosystem and how it fits into the big picture of making your big C++ app crash-free and reliable.

This talk is aimed at Valgrind (Memcheck!) users and developers. It should be accessible to C/C++/Fortran developers who have used the tool or are thinking of doing so.

Rolling Releases are the future of Linux distributions. They are already the better solution for power users & developers. The methodologies, techniques, and capabilities of Tumbleweed are opening up new doors, creating possibilities, and disrupting existing technologies beyond its borders. This session will explain how and why openSUSE Tumbleweed is paving the way for that future, while already being "the reliable rolling release". The talk will dispel the fears, uncertainties and doubts that many have regarding rolling releases in general and Tumbleweed specifically, and share how you can get involved both using, and improving, this exciting fast moving foundation of the openSUSE Project.

The audience is anyone interested in using recent versions of the Linux kernel or other upstream projects. This includes not only enthusiasts, but developers, especially Linux kernel developers and other developers of fast moving stacks who often benefit from having a stable platform with all the latest libraries and binaries available to them. Attendees can expect to get a solid understanding of how Tumbleweed is developed, it's strengths and benefits, as well as a comparison with Tumbleweed to other similar Linux-based rolling distributions. This presentation will encourage a broader adoption of rolling releases and the mentality, methodologies and capabilities that come with it. Tumbleweed and other similar rolling releases are key platforms to enable the high speed development of the Linux kernel and other key ecosystem components which increasingly move at a faster pace than 'traditional' Linux distributions can keep up. Rolling releases are also the natural platform for not only the development but the early adoption of key emerging technologies such as Containerisation and NFV.

This will constitute the traditional ceremonial introduction of the Legal and Policy Issues Devroom

Welcome to the Ruby Devroom 2017

opsi is a powerful tool for client management in heterogenous environments. This lightning talk will give a short overview over the system and what possibilities system administrators get with opsi for managing Windows and Linux clients.

In many environments system administrators are required to manage a wide range of operating systems. Wouldn't it be great to have a tool where one tool can manage Windows and Linux? Introducing opsi, a client management tool that allows managing both worlds.

This talk will give you an overview of the system opsi and introduces possible tasks that can be done with opsi. Handling different systems is most present when writing the scripts that perform tasks on the clients. Similarities and differences that administrators may face when creating these scripts are important for the creation and will be highlighted during that talk.

Wt is a C++ library for developing web applications and sites.

Wt provides widget-centric API to write web application as if graphical application. Wt translates this to Ajax powered site or to plain HTML site depending on the client. Unlike page-based frameworks or single-page JavaScript frameworks, Wt creates stateful applications that are at the same time highly interactive but still support plain HTML browsers or web crawlers.

Luawt uses all the power of Wt in the world of Lua. Luawt is different from popular solutions like Lapis and Sailor, because Wt is different. Target customer of luawt wants to provide web interface to a library, written in C or Lua. Luawt application can’t run directly from nginx.conf, but the application has per-session state and its code looks like GUI application's code. Luawt is not finished yet, but we have a number of solutions to automate generation of bindings using gccxml, so we expect it to become a practical solution very soon.

We would like to give a talk about luawt in order to show its facilities and demonstrate several examples how it could be applied in everyday web development.

Homepage of luawt: https://github.com/LuaAndC/luawt Luawt is delivered to you by Pavel Dolgov (github.com/zer0main) who is a CS student and open source developer and Boris Nagaev (github.com/starius) who is a site reliability engineer.

Internet of Things devroom opening and Pieter Hintjens in memoriam.

SDN & NFV together are technologies intended to ease connectivity and access to content and workloads. This talk with address the need for open/programmable/available access technologies to make this a reality.

Access virtualization is one of the focus areas across the networking industry and provides some of the greatest opportunities to explore new approaches to connectivity and new models for carriers and others providing internet services. This talk with look at ongoing initiatives in this area such as ONOS/CORD, OpenDaylight, OPNFV and present a set of common goals, valuable to our ecosystem, being addressed across these implementations.

The session will look at the issues developers run into when developing their own WebRTC applications. It looks at the problematic elements in the API, the compatibility problems between browsers, missing infrastructure, and even the human element. All in all, it's a demonstration that a true WebRTC application can't be built in a snap.

Last year, I presented a talk explaining how easy it is to build a WebRTC application.

This year, I'll tell you the truth!

It will cover both the ideas and code necessary to move your basic application into something that resembles production-ready.

In 2016 Mozilla did a qualitative exploration project into the experiences and motivations of community members from several different open source projects.

The results have been crucial in understanding what we are doing well, not so well and what others are doing better in open source engagement.

The presentation will go through the identified motivations and experiences as well as present the 4 persona's that were developed. The research will give you concrete understanding of how people engage with new open source opportunities and set examples for how to use the research in your own community work.

As a hardcore OpenOffice and game player/hacker, I always keep detailed game records with Calc spreadsheets, including characters, stats, resources, event plans, etc., so that I can get the best of it. When it comes to Pokémon GO, I keep the Pokémon individual values (IV), maximum combat powers (CP), and other information that calculated from 3rd-party websites on my spreadsheets, in order to plan which Pokémon to spent precious resources to power up. The spreadsheet document eventually becomes an application that works completely off-line.

You can always do everything with OpenOffice, for fun!

Opening the devroom and welcoming all attendees

During this presentation we will see how to manage infrastructure which is used to run containers. We will see how to use reliable vms provisioned by ovirt and run openshift containers on them by using single management UI (manageiq) with ansible modules.

While python has developed into the lingua franca in Data Science there is often a paradigm break when accessing specialized tools. In particular for one of the core data categories in science and engineering, massive multi-dimensional arrays, out-of-memory solutions typically employ their own, different models.

We discuss this situation on the example of the scalable open-source array engine, rasdaman ("raster data manager") which offers access to and processing of Petascale multi-dimensional arrays through an SQL-style array query language, rasql. Such queries are executed in the server on a storage engine utilizing adaptive array partitioning and based on a processing engine implementing a "tile streaming" paradigm to allow processing of arrays massively larger than server RAM. The rasdaman QL has acted as blueprint for forthcoming ISO Array SQL and the Open Geospatial Consortium (OGC) geo analytics language, Web Coverage Processing Service, adopted in 2008. Not surprisingly, rasdaman is OGC and INSPIRE Reference Implementation for their "Big Earth Data" standards suite.

Recently, rasdaman has been augmented with a python interface which allows to transparently interact with the database (credits go to Siddharth Shukla's Master Thesis at Jacobs University). Programmers do not need to know the rasdaman query language, as the operators are silently transformed, through lazy evaluation, into queries. Arrays delivered are likewise automatically transformed into their python representation.

The presenter is Principal Architect of rasdaman, editor of several "Big Data" standards, and co-chair of "Big Data" relevant working groups in several high-impact bodies. In the talk, the rasdaman concept will be illustrated with the help of large-scale real-life examples of operational satellite image and weather data services, and sample python code will be demonstrated live.

Traditional container technology (i.e. Docker) was not meant for the deployment of HPC applications among large computing clusters. New container technology like Singularity focuses on the portability of compute, allowing us to ease deployment, reducing administrative overhead and user support. However, some issues still need special attention, for example how to handle different MPI configurations (e.g. over Infiniband), and how to handle special resources like GPUs.

Today, there is no need to have applications installed on any cluster or HPC/scientific resource; we can use container technology to encapsulate all the software and libraries of any specific application, ensuring the operation thereof in any possible operating system, software, and hardware architecture, avoiding  incompatibilities and retaining native or near-native performance. Our design strategy makes the container agnostic to the queue system i.e. the container works with SLURM, TORQUE and stand alone.

This talk will cover creating such portable containers using multiple resources, and showing how simple is to deploy a complex MPI dependant application across multiple TOP500 supercomputer with only a regular user account, including the ability to exploit existing resources like Infiniband and GPGPUs.

Also we’ll show how to add open source profiling tools to the container. We are going to show execution profiling samples of critical HPC/ML applications like VASP, Amber, Seismic Imaging and Chainer running on portable containers across different HPC systems.

Drones have become ubiquitous: from small toys to remote piloted aircrafts, they are not uncommon anymore. FOSS is fundamental for the drone (or UAV) environment: several drone platforms are based on it, like Dronecode and various autopilot systems. The talk will address the possible interactions with FOSS drone components, and the pressing issues of security and privacy.

Drones were, not many years ago, an exotic item, straight from SF movies. In very few years, they have become ubiquitous, and FOSS has played a fundamental role in this very fast expansion. Several important drone platforms and software rely on FOSS components, and one of the most prominent projects, Dronecode, is governed by the Linux Foundation. The expansion of drones has triggered a regulatory frenzy, not only at the national level, but also at the European one: EASA (the European Aviation Safety Authority) has already released the second draft of the ‘Prototype’ Commission Regulation on Unmanned Aircraft Operations, which may be approved during 2017, while the EU General Data Protection Regulation 2016/679 has several articles which have a direct influence on the developing of drones. Principles like data protection by design and data protection by default cannot be ignored for developers involved in FOSS drone platforms. The talk will examine the current (and future) European Legal framework, in order to assess the interactions between EU safety security and privacy regulations, and the “FOSS powered” development of drones.

The Defense Advanced Research Projects Agency (DARPA) is hosting a pre-FOSDEM hackfest on unintentional emitters of electromagnetic signals. The hackfest should attract many people from the software defined radio (SDR) community to participate as it will involve the design and development of techniques to discover, capture, identify, and disseminate the emissions and emitters. The hackfest will take place in Brussels from February 1 – 3, so this talk will provide a review of the work that went on in the days just preceding FOSDEM.

Electromagnetic (EM) emissions are everywhere and come from radio systems that purposefully emit EM signals, unintended emissions from these radios in other frequencies, and unintentional emissions from all of our electronics, even those not designed as radios. These emissions affect spectrum usage, which is a vital part of our daily lives and continues to grow in its importance. As more services and devices are depending on wireless connectivity, the problems of interference will grow, too. We typically think about interference coming from other wireless devices, but other electronics create EM emissions as well, such as computers and vehicles. But even more mundane electronics, like AC-to-DC converter “wall-warts” for charging cell phones, produce emissions. Though often low-power, the growing prevalence of electronics to support our daily lives is also an additive source of interference.

DARPA will be hosting a hackfest in Brussels over the three days leading up to FOSDEM. The purpose of the hackfest on unintentional emitters is to help us develop techniques to find and study the emissions with the hope of better understanding and characterizing how different devices behave. The hackfest outcomes could lead to important scientific and technical knowledge for how we understand the interference problems from these emitters. Can we characterize how a building and its various components look by its EM emissions? How about parts of a city and the effects of traffic, subways, and other infrastructure?

The FOSDEM presentation will review the work that went on during the three-day hackfest and report on any resulting techniques/technology and what we learned about the unintentional emissions around us. It will be a relatively short talk presented without slides as a quick wrap-up to the FOSDEM SDR audience.

At Dropbox, with 1000s of machines running MySQL, performance is important. Among other things, out team is responsible for our MySQL servers being tuned well. In this talk, we will talk about the performance impact of “environmental” MySQL tuning, where the tuning is neither at the SQL level (like creating indexes or using different table structures), nor with setting MySQL parameters (tuning parameters like innodbbufferpoolsize or innodblogfilesize even more obscure ones like innodblruscan_depth). Instead, in the talk we will cover the following areas (we won’t limit the talk to these):

• Operating system level tuning opportunities
• Compiling MySQL: does it worth to build your own from the performance perspective?
• Building MySQL with different compilers
• Building MySQL with profile-guided optimization
• Impact of using different memory allocators
• CPU and memory affinity with running multiple instances

The experiments we conducted here helped us to make more educated decisions about how to run MySQL at Dropbox.

An initial basic and generic introduction for beginners on Disaster Recovery with Relax-and-Recover.

This basic introduction on Disaster Recovery with Relax-and-Recover will explain the following items from a generic higher-level point of view:

• What does disaster recovery mean ?
• How does disaster recovery work ?
• What disaster recovery is not meant to do
• What is Relax-and-Recover ?
• How does Relax-and-Recover work ?
• How to set up Relax-and-Recover
• Relax-and-Recover advantages/disadvantages
• Relax-and-Recover limitations

A fundamental aspect of the Genode OS project always was the support for various kernels as back-end. It remarkably raised testing versatility and provided a high flexibility to users and developers. But supporting the Genode API on self-contained third-party kernels is sometimes also accompanied with deficiencies, redundancies, or work-arounds. To also have the option of a basic kernel without such compromises, the custom Genode kernel was developed. Its main distinguishing mark may be that it not only trusts the Genode Core-component but even more is a mere library to it. The implications of this new design and other characteristics of the custom Genode kernel, such as scheduling, capabilities, and ARM virtualization, are discussed in this lecture.

I am going to present modern concurrency tools provided by concurrent-ruby gem These modern concurrent tools provided by concurrent-ruby gem are inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and some classic concurrency patterns. We will go through detailed example of each of the feature

In this talk, I am going to present modern concurrency tools provided by concurrent-ruby gem http://concurrent-ruby.com

These modern concurrent tools provided by concurrent-ruby gem are inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and some classic concurrency patterns.

We will go through detailed examples about how to use each of the feature.

I am also going to cover little theory of classic concurrency models such as CSP, Actor Model, Event based so that we will understand importance of these modern concurrency features.

This talk will be very useful for modern Rubyist to understand concurrency abstractions those can be used at application code.

Starting from LibreOffice 5.3, LibreOffice user interface will be improved with the addition of a notebook bar which integrates with the existing layout. A background on the rationale.

Welcome to the Free Java DevRoom!

Real-time applications are growing in popularity across almost every industries : Gaming, IoT and smart home, Healthcare, Transportation, etc... - What are the main technologies, frameworks and protocols used for building real-time applications and how reliable, secure, efficient and scalable are they ? - Which stacks are used amongst the industries to build real-time infrastructures ?

When the Ingress game started in 2013, quite a few people world-wide found out that augmented reality gaming in the real world was a great new invention, and the game grew to become a success for the then-project inside Google. With its Pokémon themed update in 2016, Niantic got the whole world playing - and sponsoring them with all their personal details. Veripeditus opens up the world of AR game creation to the public.

The Pokémon Go hype is spreading and more and more people are playing - on a real map with real objects. With the ever growing possibilities of smart phones and apps, interest for Augmented Reality is getting bigger. But there are obvious problems: current developers don't care about privacy and data is collected, sold and freely provided to others at will.

About time to make a change! Veripeditus is entirely free, open source software and easy to use. The server can be run entirely by yourself and everyone can develope games and custom clients if they wish. The frameworkd allows for the development of augmented reality games, so called "cartridges", that can be played in the real world in any scope, be it locally, like on the premises of a museum, or on global scope, like an augemented reality MMORPG.

In the development of Veripeditus, we aim at making game development as easy as possible. The only thing needed is basic knowledge of Python and, of course, ideas for the game. Veripeditus itself also employs basic, well-known technologies like a relational database, the SQLAlchemy object-relational mapper and a (glorified) RESTful API.

This talk will give an introduction to how Veripeditus was developed, how games can be created and what can be done with it - some ideas include using Veripeditus in education, local group activities, tourism amd, of course, plain fun gaming.

We will also showcase a mini game that will be playable on the ULB campus!

Next Generation Config Mgmt

A presentation about a next gen config management tool, and the specific problems this project solves.

Three of the main design features of the tool include: * Parallel execution * Event driven mechanism * Distributed architecture

This talk will demo a prototype I've built that implements these ideas and which is written in golang. I will start by presenting an introduction to the tool. I will then demo the new features that were added since the project was introduced. This will include the automatic grouping, automatic elastic etcd clustering and remote execution features. I will finally share some of the future planned designs for the tool.

An introductory blog post on the subject is available. https://ttboj.wordpress.com/2016/01/18/next-generation-configuration-mgmt/ Attendees are encouraged to read it before the talk if they are interested!

Please note that this talk was originally scheduled to be given at 15:00. The talk originally in this slot, "Puppet Catalog Diffs in TheForeman" by Greg Sutcliffe will now take place at 15:00.

To offer supercomputing services to all Cuban institutes of higher education, research centers and industrial partners is the mission set forth by a group of ambitious young system administrators working at various universities of the lush Caribbean island of Cuba. With the assistance of the Flemish Inter-university Council (VLIR), lots of hard work and hardware donations by Ghent University they have succeeded in setting up a nation-spanning architecture comprised of three datacenters, in Havana (West), Santa Clara (central) and Santiago de Cuba (East). Their campuses are spread geographically across the 1000 km long island and are interconnected by a 20 Mbps network that covers up to the furthest regions of the island where remote rural universities are given the opportunity to take advantage of the magnificent capacities of massive parallel processing.

Thus was born "HPC Cuba" the national center for academic supercomputing. While fully depending on Free Software for their operations, HPC Cuba has also joined the global Free Software community by producing installation packages for software not yet covered by EasyBuild.

On a tropical island where access to resources is being limited by a US imposed trade embargo, setting up a datacenter capable of hosting a proper supercomputer "no es fácil" ("it is not easy", a Cuban saying). Come learn about the specific challenges poised in the Cuban context, calling for resourceful solutions and unique problem-solving capacities standing proof of the high standard of the universities of this so-called third world country and its relentless human resources.

KEYWORDS: Cuba, University, Development Coooperation, VLIR-UOS, Free Software, National Center for Supercomputing, Distributed, HPC Cuba

Scientific aircraft research flights have to be planned beforehand. For that it is necessary to have model forecasts of relevant quantities such as meteorological parameters, chemical composition or particle information to guide the aircraft to the location of interest. We develop the MSS Project to make decissions easier where to investigate.

Scientific aircraft research flights have to be planned beforehand. For that it is necessary to have model forecasts of relevant quantities such as meteorological parameters, chemical composition or particle information to guide the aircraft to the location of interest. Typically, many scientific instruments on board those aircrafts used to investigate e.g. the chemical composition of the air in order to get new insights often with the involvement of different science groups.

For discussion of the possibilites of the research flights, the Mission Support System (MSS) was developed. This software helps to review a big amount of metereological and model data by viewing the forecasted parameters of interest along possible regions of a proposed flight path. Data and possible flight paths can be displayed on a hoizontal view (map projection) or on a vertical view (along the proposed flight path). Flight paths can be constructed and modified on these views. Exchange through a waypoint table is also possible.

The talk gives a brief insight into the MSS software development current state.

We are using the OWS interface standard. https://geopython.github.io/OWSLib/ MSS is a client/server application. The QT client interacts with a paste wsgi server. The software is available for all platforms on conda-forge.

Free and Open Source Software (FOSS) constitutes the bulk of the Software Commons, and is at the heart of our digital society. We discuss why and how the Software Heritage project is taking over the mission of ensuring that this precious body of knowledge will be preserved over time and made available to all.

The Software Commons is the vast body of human knowledge embedded in software source code, that is publicly available and can be freely altered and reused. Free and Open Source Software (FOSS) constitutes the bulk of it. Sadly we seem to be at increasing risk of losing this precious heritage built by the FOSS community over the paste decades: code hosting sites shut down when their popularity decreases, tapes of ancient versions of our toolchain (bit-)rot in basements, etc.

The ambitious goal of the Software Heritage project is to contribute to address this risk, by collecting, preserving, and sharing all publicly available software in source code form. Together with its complete VCS development history. Forever, of course.

By doing so Software Heritage will serve the needs of: Society, by preserving our collective technological heritage; Industry, by building the largest software provenance open database; Science, by assembling the largest curated archive for software research; and Education, by creating the ultimate anthology for programming curricula.

Although still in Beta, Software Heritage has already archived more than 3 billion unique source code files and 700 million unique commits, spanning more than 45 million FOSS projects from major software development hubs, GNU/Linux distributions, and upstream software collections.

Software Heritage is developed transparently as a collaborative project and all its own source code is available as FOSS under copyleft licenses. Currently incubated by Inria, the project will graduate soon to an independent charitable, nonprofit organization.

GNU Radio is a free and open source toolkit for software radio, and has been part of the GNU project since 2001. This talk will kick-off the Software-Defined Radio Dev Room with a quick introduction to software radio. I will then give a brief introduction to GNU Radio, and then go into some updates about the project and development direction, and provide some examples of some of the awesome stuff happening in the software radio community.

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

Clouds are spreading and software is eating the world. But software depends on hardware. If that hardware is not trustworthy, open and secure, the software's trustworthiness, openness and security is for naught. The Free Software community has been forced to live with this conundrum for lack of good alternatives. Too pervasive and omnipresent was the Intel defined x86 architecture, throttling innovation, while sequestering security and control from its users.

Most of the discussion in our community centred around damage control and preventing being locked out from the platform for good. We focused our efforts on protecting our ability to use our own software. Positively shaping the future, driving the direction, and solving the problem of trustworthy hardware for good and at scale seemed impossible.

But, the thing is, without (almost) anybody noticing, all of the above has changed.

Georg Greve, CEO of Kolab Systems, will talk about the journey Kolab took to discover OpenPOWER, what we found in the OpenPOWER Foundation, and what it all means for Free Software.

In this session you will learn how far we have come in our quest to run a data centre for High Performance Computing on a complete open hardware and software platform, a platform that, at the same time, far outperforms Intel. We will also cover the TALOS secure work station and what it brings to our community.

A community building project around the Firefox Nightly Channel

Every day, we compile the code for Firefox on our master branch, mozilla-central, and generate builds without the Firefox branding, those are called Firefox Nightly build. Until recently, those builds were barely mentionned or promoted on mozilla.org, localized versions existed but were only known to the localizers themselves, the download page was on a separate domain and hadn't been redesigned since 2011.

As a result, we have very few Firefox Nightly users.

What would be the impact for Mozilla if Firefox Nightly became a first-class citizen among Firefox channels? How about getting back more technical users on this channel reporting bugs as they get introduced into our codebase instead of weeks or months later? Could we ship faster and better quality software if we had an army of Nightly testers reporting regressions and giving their feedback on a daily basis? How about engaging our existing community of power-users directly into the production process for Firefox as a long term participation project?

This talk is a recap of what the release management team has been working on in the last 8 months to turn the nightly channel in a more useful tool leveraging our existing community to ship a better Firefox and what we expect to do in 2017 around the nightly channel to serve our QA needs.

Overview of 5G, network slicing, and OpenAirInterface

One of the interesting aspects of the 4G/5G era is confluence between the open-source software-defined networking technologies used in mainstream fixed networks and the closed-source technologies used the access and core components of cellular networks. This poses significant challenges from a legal standpoint because of the required mix of the two software technologies in common data centers. This conflictual relationship is aggravated further with the emergence of mobile edge computing. Once the legal issues are ultimately resolved, as it seems to be the case, the main issue will be that of satisfying real-time processing constraints for the radio-access network functions. These stem from the latency requirements of cellular systems when the radio-access procedures are executed on commodity servers. Moreover, when network function virtualization is put into the picture to allow for techniques such as network slicing to descend down in the radio-access network, the situation becomes even more challenging from a real-time perspective.

This talk will provide an overview of the evolution of 4G networks towards 5G and some of he new applications and industries that will be enabled by it. We also cover the role of the OpenAirInterface Software Alliance and how it is trying to soften the blow of clash between open and closed-source communities in radio-access and core networks along with its relationship with some of the other related open-source communities. The talk will also cover some technical aspects related to the difficulties in virtualizing radio-access network functions on commodity servers when it comes to real-time requirements, orchestration and management.

Google’s chromebooks and routers use off the shelf Microcontrollers (MCU) to do power sequencing, fan control, PWM and other hardware control tasks one typically encounters in embedded systems. Interestingly enough the firmware is available under (3 clause) BSD license and thus open for hacking, abusing and modifying to your needs.

We’ll look at a bunch of MCU options and eval boards to get started with, their availability and pricing in low quantities as well as ways to hook them up to your embedded platform. Moreover we’ll look at hardware level requirements your SoC / board will have to provide in order to make it all work.

We’ll cover existing driver / software support in upstream Linux and U-Boot, as well as parts that are or were missing.

Typical tasks of an embedded controller for a chromebook or random other devices like mine - which is everything but a laptop - will be discussed. Topics covered will include boot selection, firmware upgrades, watchdog timers and others.

Finally I’ll share my experiences building a real world Zynq based system using chromium-ec on an STM32 MCU and my experiences adapting the software to my needs and interacting with the community. Examples include replacing the coreboot bootflow with U-Boot, creating device drivers for things like buttons and issues encountered in making things work.

There are many IoT dashboards out on the web, most will require network connection to a server far far away, and use non standard protocols. We will show how to combine free software tools and protocols from the worlds of IT monitoring, Industrial control and IoT to create simple yet robust dashboards.

Modbus [1] is a serial communication protocol developed in 1979 for use with programmable logic controllers (PLCs). In simple terms, it is a method used for transmitting information over serial lines between electronic devices., it’s openly published, royalty-free, simple and robust.

Many industrial controllers can speak Modbus, we can also teach “hobby” devices like Arduino boards and ESP8266 to speak Modbus [2]. Reliable, robust and simple free software Modbus client [3] will be used to acquire the metrics from our device, then the metrics will be collected [6][7] and sent to Hawkular and Grafana [8] to store and visualize our data.

(*) http://starwars.wikia.com/wiki/Bocce

[1] https://en.wikipedia.org/wiki/Modbus [2] https://github.com/yaacov/ArduinoModbusSlave [3] https://github.com/yaacov/node-modbus-serial [6] https://github.com/hawkular/hawkular-client-python [7] https://github.com/yaacov/hawkular-client-cli [8] https://github.com/hawkular/hawkular-grafana-datasource

The new VDEplug code now supports a URL-like syntax to define the virtual networking system to use. While it is backward compatible, and it is supported by many VM (kvm/qemu, virtualbox, user-mode linux, umview), now it is possible to add the compatibility layer for current and future virtual networking environments.

Currently VDEplug supports: legacy VDE, point-to-point AF_UNIX or UDP, tap, vxlan, vxvde, slirp.

In the developing phase of the slirp plugin, we have implemented a general purpose slirp library (derived from qemu's slirp implementation).

VDEplug4 together with new tools for the management of namespaces and capability create a new ecosystem for the support of virtual networking.

While troubleshooting MySQL performance problems it is important to find out where CPU time is spent inside mysqld process. The process of investigation should have as small influence as possible on the server we try to troubleshoot. Ideally, the source code should be instrumented for that.

Performance_schema introduced in MySQL 5.5 is supposed to provide detailed enough instrumentation. But it comes with a cost, require careful sizing of performance counters, and the process of instrumenting the code is not yet complete even for MySQL itself, to say nothing about 3rd party storage engines, plugins and libraries like Galera.

This is when profilers come handy. Poor Man's Profiler (PMP, aka pt-pmp), perf and oprofile on Linux can be easily used while studying MySQL performance problems. Basic usage steps are presented and several typical use cases are discussed.

In case of any performance problems with MySQL is important to find out where CPU time is spent inside mysqld process. Is it waiting on disk I/O, some lock or internal mutex, or maybe it performs complex computation that should be optimized? You can not figure out until you know how much time each important step takes, and how often it occurs. To investigate that, one may use different tools and approaches, from tracing the code to using simple OS level utilities that show disk and memory usage in total or per device, to more advanced programs that collect all kinds of information about specific program running (these are often called profilers). The process of investigation should have as small influence as possible on the server we try to troubleshoot.

Ideally, the source code should be instrumented for that and provide a "domain-specific" performance metrics. It may be not enough to know how much time specific function runs if its code is huge and complex. Performance_schema introduced in MySQL 5.5 was supposed to provide detailed enough instrumentation. But it comes with a cost (performance penalty, that can be notable), require careful sizing of performance counters, force investigator to use advanced SQL to get the information needed. What's even worse, the process of instrumenting the code is not yet complete even for MySQL itself, to say nothing about 3rd party storage engines, plugins and libraries like Galera.

This is when profilers come handy. During this talk we'll discuss the use of Poor Man's Profiler (PMP, aka pt-pmp), perf and oprofile on Linux to study MySQL performance problems. Basic usage steps are presented and several typical use cases are discussed. These including several famous bugs (like https://bugs.mysql.com/bug.php?id=68079), profiling for Galera, MyRocks storage engine etc. Quick review of the most interesting MySQL bug reports where profilers played a key role in the investigation is also presented.

The talk presents a programmer-friendly approach to rapid prototyping of functional UI sketches for an enterprise application, using a home-grown Lua text template library and the mermaid.js command-line tool. The speaker will also share the experience of creating yet another text template library, the reasoning behind it and the lessons learned in the process of implementation.

If you run an open source project, and you'd like to get contributions from employees at medium-to-large companies, the simplest way to provide a smooth contribution process is to not use a Contributor License Agreement. If your project requires one, though, there are steps you can take to ease the burden this causes on contributions from company employees, and this talk will cover a number of issues encountered during 4+ years of managing contributions from a 20K+ employee global company.

While there is a growing movement in the open source community away from Contributor License Agreements, many important projects still require them. Some of these projects are focused on 'enterprise' usage, so as a result employees of major companies want to contribute. However, the mechanisms used to execute these CLAs vary widely (it seems that every project builds its own CLA system), and none of them take into account the various legal and logistical requirements of a major corporation who wants to contribute. This talk will present a series of problems encountered as a contributing company, and propose ways that CLA-requiring projects can resolve them.

These problems include (but are no means limited to): requiring the agreement to be executed on a social media platform; providing no ability for the authorized signer and the manager of the authorized employee list to be different people; requiring FAXed copies of agreements; failing to provide the ability to authorize employees to contribute to specific codebases within a large project; and more.

Toolbars are a common toolkit control that have been around since the dawn of GUI applications, providing direct access to an application's most frequently used functions. But with increasing scope, the number of frequently used functions grows to an extent that can have a detrimental impact on quickly locating a particular item. LibreOffice made it possible to create UI based toolbars on blank canvas where designers have all the freedom to do whatever they want with the space. The talk will present the reasoning behind the Notebookbar layout with contextual groups.

Traditionally CMSs use SQL databases that are really fast when you need all the information stored together in a record row, but are a bad fit when you need to search for relationship patterns that are not already stored together in your database. A significant performance penalty is incurred for every additional table that needs to be joined for a query. That is why SQL databases are notoriously bad at deducting relationships from datasets. Graph databases however are really good at this task. In this talk we discuss potential application areas of graph databases in existing open source CMSs like Drupal.

We believe graph databases could make a big difference when used in key areas where traditionally CMSs would fail: Explore large non-uniform datasets: Neo4j got a lot of attention after it was used by investigative journalists to identify the organisations and individuals involved in offshore tax evasion in the Panama papers leak. Recommend content: Media companies like the Financial Times are using Neo4j to display related content on their website, this helps them to increase engagement with higher clickthrough rates. Personalisation: Addidas uses the Neo4j graph database to create it’s internal metadata service, offering access and searchability to their data and making sense of complex interdependencies and relationships.

We've created a basic integration that makes it possible for non-developers to work with Neo4j. Combined with Drupal’s content modelling capabilities we believe it could be a powerful tool for people to explore graph databases using a GUI. There is also a case to be made for the use of graph databases in the Drupal ecosystem: sites that already use Drupal could benefit from its capabilities.

An introduction about DRLM (Disaster Recovery Linux Manager) features, news and a complete workshop on DR management with ReaR and DRLM.

DRLM Project Intro: will explain the following items:

• What is DRLM ?
• DRLM Short History
• DRLM Features
• News on version 2.1.0
• How to contribute ?

Workshop: will provide the opportunity to dig into topics relevant to real DR needs and to get your questions/doubts answered

• How to set up DRLM
• DRLM Operations (manage networks, clients, backups, jobs, etc.)
• Best Practices
• Questions & Answers

The current state of the Telepathy project and its vision for the future of real-time communication on the desktop.

Recent developments in the Telepathy project have brought it again on the front, after years of inactivity. In this talk we will look through what is going on in Telepathy recently and what are its plans for addressing real-time communication needs on the desktop.

No, Firefox DevTools are not Firebug. The web came a long way since Firebug, and so have the DevTools baked into Firefox. So let's go exploring!

As the complexity of the web apps you build keeps moving, so do the Firefox DevTools.

In this session, Alex will give you the latest tips and tricks on Firefox DevTools. We'll explore new and less commonly known features in performance profiling, JavaScript debugging and animation inspection. The session will give you a productivity advantage when developing and debugging your web applications.

Intro to ham radio and a brief demo of SDR capabilities in the Debian Ham blend, explaining why Debian and Ham Radio are both important parts of the SDR eco-system.

The network equipment world long ago embraced Linux as a base operating system, but one aspect got left behind: the switch chips at the core of this equipment are still stuck in the binary blob era. The switchdev subsystem in the Linux kernel is here to help.

In this talk we'll take a close look at a one of the "smart" (WiFi-connected) light-bulbs available on the market today. The bulbs expose a small API over UDP that I used to run an interface on a programmable buttons array. We will see how topics like reverse engineering, security, licensing, "self-hosting" and user experience came into play.

monolight is an user interface to control LIFX WiFi-enabled light bulbs. monolight runs on a programmable button array; it is written in Python 3.6 (to have type annotations and asyncio), and it interfaces with the bulbs through a more complex daemon written in C: lightsd.

This talk will start with a live demo of the button grid remotely controlling the light bulbs. We will then explore how it works and some of the motivations behind it (network isolation, trying to not depend on the "cloud", reliability, user-experience). Finally, we will look into what kind of opportunities even more open IoT products could bring, and open leave the place to Q&A and discussion.

SPARC is an instruction set architecture (ISA) originally developed by Sun Microsystems since 1980's. Today's largest enterprise servers run on sparc, leveraging several terabytes of memory and several hundreds of CPUs. This talk will briefly introduce key concepts of sparcv9 ISA and the big picture where support of a new architecture fits into Valgrind architecture. Some interesting problems during the port will be discussed together with solutions and still-to-be-solved issues. Finally a live demo will conclude the talk. The talk assumes basic knowledge of Valgrind, interaction among Valgrind subsystems, basic assembly and VEX IR notation. It is targeted to all interested in sparcv9 ISA and running Valgrind on sparc.

A whirlwind update on Project Jigsaw, a long-term effort to design and implement a standard module system for the Java SE Platform and apply that system to the Platform itself, and to the JDK.

Algebraic operator are every where in python. + = * / Dict are every where in python.

What can we achieve by combining both of them?

Slides are here

Introduction

Algebra is a wonderful abstraction that make the infamous 2D point example of a class or nameddict useless when you have complex data type (that is HW accelerated on Intel CPU).

I Algebra 101 : it is all about consistency between symbol and behaviour

Simple: Is something consistent with linear algebra? it requires 17 simple unit tests suffice to say so

So just let makes a test this rules are followed, and then a class that applies these behaviours and we have implemented it.

II I have linear algebra behaviour. How useful can it be?

Well, you have basic data type like { x: 1, y :2, z :3 } that is actually behaving like an euclidean vector.

If an object is a MutableMapping thus we can create a universal operator for saying how much an object «looks like» another one. Practical use :

• finding doublons in database;
• text matching (after a pass of ntlk + word counters);
• pattern fitting;

...

That is the basis of Textual indexation and profiling (it is not only for evil purpose) https://github.com/jul/ADictAddiction/blob/master/example/cosdemo.py

III State of the art of 2 working POC how to use MutableMapping (dict) and super

Most of the operation tested here https://github.com/jul/ADictAdd_iction/

Implementation as a trait here https://github.com/jul/archery

Basically it works BUT :

1. it is hard : with archery I stumbled on super
2. with VectorDict (obsolete) it lacks of genericity and the code is clumsy
3. python 2 div behaviour was screwing this (and since these library were relying on base operator, I got biten)

Prepare to throw 2 away

IV the future

A chain is as strong as its weakest link : if a lib is based on composing the python based operator, the algebra will be as consistent as the CORE behaviour of the operator in the language.

Conclusion

Algebra is a powerful abstraction that is still underused.

Possible development : - Rieman/Hermitian algebra: using the power of the math used in Quantum Mechanics/relativity and python in the same fashion - Using Quaternion to have quirkless rotation in euclidean 3D...

This talk will present two ways of working with LibreOffice user interface elements for an extension or a macro - legacy Basic dialog designer, as well as the new feature using .ui files editable by Glade

User interface for LibreOffice extensions and macros has never really been in the spotlight of attention of LibreOffice developers and users despite the fact that built-in dialog designer was pretty advanced piece of software in its time. It still contains quite some powerful features (such as drag-and-drop editor, live preview or easy access to l10n). And while core LibreOffice dialogs have been converted to modern .ui format (thus making it possible for LibreOffice developers to use even more powerful UI editor - Glade), LibreOffice peripherals were still stuck with legacy home-grown obscure formats.

Come and see for yourself that extensions and macros don't have to be dull, interfaceless pieces of software and that with minimum effort and basic knowledge of UI design, you can make them rock. Now you can even use all the capabilities of Glade as .ui format can be read by/included in extension or macro as well.

HPC computing environment and especially super computing has its bag of challenges when it comes to software deployment. As scientists we often do not get root access which means that we either depend on what software is available or we build software in a dedicated directory using tools such as Brew, Conda or even from source. Unfortunately these solutions depend on already installed tools from an underlying distribution, often proprietary or dated compilers, and, for example, modules. Any binary that gets produced, therefore, tends to be totally unique, both in the generated binary and its set of dependencies. This is bad, both for trouble shooting and for pursuing reproducible science. With GNU Guix we are developing a fully reproducible free software stack including all dependencies targeting cross-builds for heterogeneous computing environments, such as the Beacon Intel PHI-based supercomputer, without having a requirement for containers. In this talk I will describe the challenges we are overcoming and what it will mean for the HPC community to have architecture optimized and fully reproducible build targets that can be deployed in a non-root, non-container environment.

Live patching -- the process of updating software while it is running -- has become a popular topic of late, with several companies offering services providing live patching for Linux culminating with an implementation being contributed to Linux. While Xen supports live migration of VMs which mitigates the need for live patching, there are still some reasons why live patching is useful. For example, to minimize downtime, when running applications with low latency requirements, and when using PCI passthrough.

This talk reviews the state of live patching for Xen. A live patching implementation has recently been contributed to Xen so we will look at the design and implementation in detail, noting how and why it differs from live patching for Linux. We will look at some of the ways that live patches can be created and the pitfalls to watch out for when doing so. There will also be a status report of ongoing and future work for live patching for Xen. Finally, the talk will show a demo of live patching in action by building a live patch for a known security issue and applying it to a vulnerable system.

Xen LivePatch is a new tech preview feature in Xen 4.7 for live patching the hypervisor. It is the result of collaboration between several members in the community guided by the existing live patching efforts for Linux. We will talk about this and how Xen's requirements differ from Linux.

The core idea of Xen LivePatch is to insert a "trampoline" in each buggy function with a jump to a replacement function. This is simple in principle, but there are a number of complexities which make it interesting to look at.

Live patches can be built by hand, by compiling the replacement functions in a separate source file. This is a manual process and can also be unreliable due to the nature of compiler optimizations. So we repurposed kpatch's live patch creation tool for Xen. This computes a binary difference of the output binaries before and after a source patch is applied. This simplifies the process of creating live patches and overcomes issues with compiler optimizations but is still not without difficulties. We look at the process of creating live patches and why it is hard.

The MySQL Performance Schema provides an interface to plugin developers that allows you to instrument your own plugins via the Performance Schema infrastructure, such as file IO latency and usage, memory usage, and mutex or other synchronization point wait times. Come to this session to understand the key points to that instrumentation interface, and how to start using it.

Many projects start out with the intention of staying single license FOSS projects. As your project grows, reality hits: some components or files may need to use different licenses than originally anticipated. There are many reasons why this can happen: you may need to interface with projects of another license, you may want to import code from other projects or your developers may not understand the subtleties of the licenses in use. Besides the obvious challenges of managing mixed license FOSS projects, such as license compatibility and tracking what licenses you use, you are running the risk of exposing your project to unintended consequences.

This talk will explore unintended consequences, risks and best practices using some examples from the recent history of the Xen Project. In particular we will cover:

1. Refactoring can lead to licensing changes: best practices and unintended consequences when importing code from elsewhere. Making code archeology easy from a licensing perspective and why it is important.
2. A worked example of a license change of a key component: process, pain points, their causes and how they could have been avoided
3. The perils of LGPL/GPL vX (or Later): the unintended consequences of not providing pre-defined copyright headers in your source base

We will conclude with a summary of lessons and best practices.

In my presentation I will focus on my project during Google Summer of Code program (mentor Hisham Muhammad). I will tell basic informations about this program and then continue to talk about our main goal, which was to increase quality of LuaRocks test suite, use new features from Lua unit testing framework busted and how to use / extend this suite. We implemented the new test suite with Lua unit testing framework busted and changed Continuous Integration practice.

Content of presentation:

• Basic informations about Google Summer of Code program
• Basic introduction to Unit test
• Advantages of Lua unit testing framework busted
  • Main features of this framework
  • Smarter tests that check execution and results
• Idea of black-box testing based on old bash script used before
  • Few details about old style testing of LuaRocks
  • What was used from old suite
• Multi-platform of this suite (Windows primary)
  • OS X on TravisCI added
  • Which tests are executable on Windows
  • Known issues with Windows platform
• Some specific tests, how we deal with black-box tests problems
  • Example of creating mock http server (kind of system testing)
• What was needed to be changed in LuaRocks Continuos Integration practice
  • Example of yaml files
  • Codecov.io instead of Coveralls.io
• Merging results of tests from more services
  • Example of new test results

How can we secure IoT and provide for a robust single point of access? XMPP Powered by Tigase can provide an easy touchless setup, a single point of access, and secure access to connected devices.

Currently the IoT world is a wild west of open devices and insecure access. Given the recent DDoS attack on the eastern seaboard of the US being spawned by such technology, it may be easy to disregard the IoT as a flash in the pan technology without much promise. But to do this would be to discount the benefits the Internet of Things can offer. Using the real time communication power and built in security of XMPP, we at Tigase have developed an instant access box to serve as a unified device for IoT devices while providing easy setup for your internet connected devices.

Consider a home thermostat that is IoT enabled. Currently, the device itself is forward facing using some sort of HTTP page, protected by a simple password challenge. To be able to access this device while outside your home network, you will need to leave this device exposed to the greater internet. Your publicly available IP now has a front door that can be beaten by brute force. Granted, the worst somebody could do in that situation is inflate your HVAC bill for a day until you figure out that 18°C is not an appropriate house temperature. Still, many devices that feature IoT come with very little unified security built in, and even then may have the most rudimentary of security built in.

XMPP can provide the solution; a single device to unify, secure, and provide access to IoT devices in the home.

C Ruby's garbage collector has come a long way since the good old days of Ruby 1.8. We'll walk through over 20 years of GC history in the C Ruby runtime, and along the way we'll talk about the key features that were added with each Ruby version. We'll cover the 5 (!) different GC algorithms C Ruby has used since 1.8, copy-on-write optimization, and possible optimizations for the future. No prior knowledge of GC or the C Ruby runtime is required for this talk.

By covering the long and varied history of Ruby GC, this talk ends up being a general introduction and discussion of concepts in garbage collection in high-level languages. We'll cover the 5 different algorithms Ruby has used, copy-on-write optimization, and how the Ruby C API has sometimes held back garbage collection in the runtime. I'm aiming this talk at people who have never thought about such topics before, but have a few years of Ruby experience under their belt.

I have been debugging and writing about issues in Ruby memory usage for some time now, and I think we could all benefit from plugging up this "leaky abstraction" in our Ruby knowledge.

HelenOS is a portable microkernel-based multiserver operating system designed and implemented from scratch. It decomposes key operating system functionality such as file systems, networking, device drivers and graphical user interface into a collection of fine-grained user space components that interact with each other via message passing. HelenOS does not aim to be a clone of any existing operating system and trades compatibility with legacy APIs for cleaner design. Most of HelenOS components have been made to order specifically for HelenOS so that its essential parts can stay free of glue code, franken-components and the maintenance burden incurred by them. In this talk I will do the annual HelenOS project update.

Please note that the talk will be given by Martin Děcký instead of Jakub Jermář who, caused by illness, will not attend FOSDEM.

How can we evaluate a global query on huge graphs in 0.1 seconds? Given our current technology, that would be magic. The lack of wizarding skills did not stop us, however, from tackling the problem by using smart caching structures, which are witchcrafts on their own.

Why is this challenge important? Several applications evaluate global queries on continuously changing graphs: fraud detection in financial transactions, analysis of source code repositories and validating engineering models. Current approaches employ domain-specific optimizations, which are difficult and error-prone to implement. Meanwhile, the requirements of these (and similar) use cases could be uniformly addressed by incremental graph query evaluation. With this technique, the first execution of the queries takes some time, but once the result are calculated, they can be efficiently maintained for each change in the graph.

To allow incremental queries on property graphs, we implemented the ingraph engine, based on the openCypher language specification. We aim to support the standard subset of openCypher, as most standard constructs can be calculated incrementally. We already mapped some of the standard constructs to relational algebra, defined incremental relational algebraic operators and implemented them in an incremental relational engine using Akka actors.

We start the talk by presenting use cases that evaluate complex global queries on continuously changing graphs and discuss the idea of incremental graph queries. We show the mapping of basic openCypher constructs (e.g. MATCH, WHERE, WITH, RETURN) to relational operators, such as joins, selections and projections. Finally, we show our approach for optimizing incremental graph queries and outline related challenges.

Target audience: Developers, looking for a deeper understanding of openCypher and/or facing complex queries on continuously changing graphs

A number of new components have matured in GENIVI to provide a true connected car experience. A couple of them are key connectivity components; namely SOTA (Software Over the Air) and RVI (Remote Vehicle Interface). This talk will discuss both these components, how they work together, the security work done on them and their integration into the GENIVI Development Platform.

This talk will also run down the overall status of GENIVI's development platform and how it can enable an automotive stack to speak not just with the cloud, but with IoT devices via Iotivity interface. The new GENIVI Development Platform (GDP) technical lead, Zeeshan Ali, will give the talk.

One of the fundamental problems with UNIX-like operating systems is that they don't seem to make it easy and intuitive to develop applications that are strongly hardened against exploits through sandboxing. With CloudABI, we're trying to make this process a lot easier.

CloudABI is a blend of POSIX and pure capability-based security, which allows you to create applications that are only capable of accessing those things that they are designed to use. As you'll see, software also becomes easier to test and deploy as a result of using this model.

In this presentation I am going to discuss a project I've been working on over the last two years, called CloudABI. CloudABI is a simplified POSIX-like runtime environment that is inspired by FreeBSD's Capsicum. It allows you to create programs that can solely interact with the environment through file descriptors (capabilities). Compared to traditional UNIX-like systems, this approach has three advantages:

1. It reduces the impact of exploits. If an attacker manages to take over control of a CloudABI application, it can only access those resources that the application was designed to use (for a networked service: typically an already bound TCP socket and some data directories). This is different from most traditional UNIX-like systems, where an attacker would gain access to all resources that the user running the application can access, which is very broad.

2. It makes applications easier to test. By knowing that an application can only access those resources that are provided explicitly, the entire environment in which the application runs can be customized for testing.

3. Similarly, it makes applications easier to deploy. This model tends to reduce the need for using containers and virtual machines. Applications can be started directly, while still providing the necessary isolation from the rest of the system.

In this talk I'm going to explain how CloudABI works in detail, while also discussing some of its design decisions. I'll also show how you can design your own CloudABI programs.

CloudABI is available for Linux, FreeBSD and Mac OS X. A NetBSD port also exists.

The aim of this project is to collect air quality information (fine dust particles) by means of a device that collects fine dust (PM1.0 and PM2.5) metrics. The device is mounted on bicycles to crowdsource factual air pollution information in and around the city of Ghent, Belgium and centralize that information for further processing.

During this presentation we will look at the hardware and firmware design. New ideas and future extensions. But we also touch on the problems related to particulate matter and air pollution.

The device uses an ESP8266 with various sensors and output devices. The firmware is written in C++ using the Arduino framework.

Do you know that Firefox now have a new technology that simplify the development of an extension? And also use and extend the API of Chrome? Yea, I am serious you can do an extension for both the browsers!

WebExtension are the future for addons in Firefox but this is not enough because they works also on Chrome, Opera and soon Edge without any changes!
Think about it, the cross browser addon issues are only an old nightmare! In conclusion because all this amazing news and how it is easy to extend Firefox will be available new APIs to customize the the Firefox experience in this year.

Dockerfiles, while being the de factor standard for generating Docker containers, are also often seen as cumbersome to write and maintain due to the nature of Docker layering, subtle behaviour changes due to caches, and best practices who requires explicit actions to be applied. To improve this situation while keeping the innovation of Docker, the Ansible community came with the ansible-container project, a tool that permit to reuse the existing trove of Ansible roles to create, build and deploy containers in production with a single command.

This talk will present the project, explain the basics of ansible-container, show how to use it to build and deploy a complex multi-containers application.

In oVirt datacenter virtualization environments, a manager directs hosts to initiate operations to shared storage. These operations create or remove volumes, copy data between volumes, create or merge snapshots, and various other actions related to virtual machine storage. For efficiency and balance these operations should be distributed across multiple hosts and run in parallel when possible. Maintaining reliability under real world conditions requires careful management and resilient algorithms. This talk will introduce some of the problems that can arise including: dropped communications, scheduling conflicts, and host or storage array failure. Next, a solution to these problems using shared storage locking, atomic operations, volume generations, and forensic analysis of the storage will be presented. Through step by step examples, the audience will understand how the proposed solution can solve all of the outlined problems.

The Transport Layer Development Kit (TLDK) is new Layer 4 implementation, developed for DPDK (dpdk.org) and VPP (https://wiki.fd.io/view/VPP).

TCP and UDP socket based applications are core technologies in the modern data-center. The introduction of Orchestration, SDN controllers, vSwitches and Virtual Dataplane have seen a huge change in how network packets are delivered to data-centre nodes. While the stacks that consume these packets, the socket based applications have evolved much more slowly. Virtual switches like VPP and OVS-DPDK, have benefited from the vector packet processing technology in DPDK to scale process millions of packets per second, while TCP and UDP socket based applications have not yet benefited. There have been a number recent efforts to port various L4 implementations to DPDK, and while these usually give a modest performance benefit the performance of these is not yet revolutionary.

TLDK has been developed from the ground up to be a very fast and scalable UDP and TCP implementation, targeted for use with DPDK and VPP. In this presentation will provide an overview of TLDK design and implementation. This deep-dive will include:-

• Overview of the TLDK UDP and TCP API, and how it differs from the BSD Sockets API.
• How TLDK scales DOS prevention mechanisms such as SynCookie and SynCache.
• How TLDK scales TCP Timers to handle millions of connections per core.
• How TLDK integrates with Virtual Switches likes VPP?
• How will existing TCP and UDP based applications such as NGINX or Apache Traffic Server benefit from TLDK?

The Transport Layer Development Kit (TLDK) is new Layer 4 implementation, developed for DPDK (dpdk.org) and VPP (https://wiki.fd.io/view/VPP).

TCP and UDP socket based applications are core technologies in the modern data-center. The introduction of Orchestration, SDN controllers, vSwitches and Virtual Dataplane have seen a huge change in how network packets are delivered to data-centre nodes. While the stacks that consume these packets, the socket based applications have evolved much more slowly. Virtual switches like VPP and OVS-DPDK, have benefited from the vector packet processing technology in DPDK to scale process millions of packets per second, while TCP and UDP socket based applications have not yet benefited. There have been a number recent efforts to port various L4 implementations to DPDK, and while these usually give a modest performance benefit the performance of these is not yet revolutionary.

TLDK has been developed from the ground up to be a very fast and scalable UDP and TCP implementation, targeted for use with DPDK and VPP. In this presentation will provide an overview of TLDK design and implementation. This deep-dive will include:-

• Overview of the TLDK UDP and TCP API, and how it differs from the BSD Sockets API.
• How TLDK scales DOS prevention mechanisms such as SynCookie and SynCache.
• How TLDK scales TCP Timers to handle millions of connections per core.
• How TLDK integrates with Virtual Switches likes VPP?
• How will existing TCP and UDP based applications such as NGINX or Apache Traffic Server benefit from TLDK?

Six years after having forked the commercial Mandriva Linux distribution and with five solid releases, the Mageia community wants to share its successes and lessons learned from developing, releasing and supporting a user-friendly and flexible distribution with an inclusive governance model. Mageia's aim is to bridge the gap between end users and developers, encouraging and facilitating contributions from all users thanks to low entry barriers and mentoring programs in its various teams.

The 100% community-driven GNU/Linux distribution Mageia was forked from the then-unsteady (and now defunct) commercial distribution Mandriva Linux 6 years ago, in September 2010. Since then, the volunteers from the Mageia community have published 5 stable releases, with the 6th one in the making, always focusing on bridging the gap between end users and contributors, to create a user-friendly but powerful system made for and by its users.

Forking a commercial distribution with paid staff to run it as a community-driven non-profit endeavour relying solely on volunteers was an ambitious move – with the perspective of those 6 years of development, the Mageia community would like to present the lessons learned, the hardships and successes it had or still has and its plans to continue progressing forward as a community-based independent GNU/Linux distribution.

The talk will aim at outlining general conclusions that could be relevant beyond the scope of GNU/Linux distributions, and therefore provide useful insights for other projects transitioning from a company-driven development to partial or full community focus.

Speakers:

Anne Nicolas is one of the founders of Mageia, and since then active as packagers team leader, member of the Mageia Council and chairwoman of Mageia.org's Board (non-profit association representing the community's interests). She is responsible for building ISO images for stable and development releases. She is also of former employee of Mandriva SA and knew well the development and governance of Mandriva Linux.

Samuel Verschelde was a long time end user and occasional contributor of Mandriva Linux when the fork was initiated in 2010. He then decided to join the adventure and to get more involved in the development of his system of choice. He is most active in the bug triage and quality assurance teams, which he helped organise and led several times. He is also a member of the Mageia Council and the Mageia.org Board.

Working with time is not a trivial challenge. Python includes a native module in the standard library to work with it but datetime keeps being together with unicode a common source of errors. This often leads to the widespread of many other libraries in the attempt of easing the work of working with datetime. Datetime is one of those API that looks easy to use but given the many concepts around time, is it easy to get backfired if the developer has not solid knowledge about the them.

In this talk we will overview the main concepts about timestamps represented through datetime objects, the limitations on the standard library and some simple steps to try to avoid the common mistakes that everyone can fall into.

Naive datetimes (which the datetime API works by default with) are a great tool to represent calendar times, but when talking about timestamps (focus of this talk) timezones is n essential part of it and the datetime module can be tricky to use for that use cases.

We will also speak about different standards of time, time zones, Daylight Saving Times, leap seconds, serialization and datetime arithmetics.

The talk will be focused on giving the foundations that everyone knows to be able to understand and work efficiently and without making painful mistakes when dealing with time related algorithms.

Audience

All developers face a time when they have to work with datetime. This is clearly not a simple domain to just jump in to. The talk will help beginners and intermediate developers to understand and don’t subestimate the complexity of working with time. The most experiences developers will also have some take aways and pointers to further their grasp of this tricky field and gain confidence on their daily usage of time related libraries.

The talk will include explanations of what “time” actually means and how can we represent it in python. You don't need to be an expert in datetime nor ISO standards, the attendees will leave understanding the complexity of time, the main concepts behind datetime and a list of tips to represent timestamps with datetime in a painless way. The talk will also include pointers to solutions for more complex problems like leap seconds, the fold attribute, etc.

Key Takeaways: - Calendar time vs Timestamps - Representations of time - Core ideas and tips around using datetime - Pointers to advanced topics

Everyone is excited about the The Internet of Things (IoT) and the possibilities of really seeing the democratization of the internet, devices for everyone needs, not just a few! If we are to achieve, then these devices must be design and built by everyone, we must create a Zine like industry, beyond the current makers of today, to enable people of all ages, gender (including non-binary), and race, to build devices suited to their own needs. LoRaWAN is a Low Power Wide Area Network (LPWAN) specification intended for wireless battery operated Things in regional, national or global networks. LoRaWAN target key requirements of Internet of Things such as secure bi-directional communication, mobility and localization services.

In this talk, I will introduce LoRaWAN as a key radio technology for IoT and walk through why it is a technologically important development as I show how to build LoRaWAN node applications to explore the possibility of IoT. There are a number of LoRaWAN networks emerging across Europe and I will highlight the political importance of why these networks should be open, supporting Open Data and Open Science and empowering the development of a new set application domains.

The lecture will involve a demonstration of an LoRaWAN application that will showcase the both the node and Gateway aspects of a deployed network.

Soon, everything on Earth will be connected via peer-to-peer networking and/or the public Internet, with a multitude of sensor-driven devices dramatically changing our lives and our environment. These devices will be based on a wide variety of devices, ranging from tiny (e.g., microcontrollers) to huge (e.g., cloud servers), with one thing in common: they will require a radio connection to a Gateway that is connected to the internet, in some form or another. While Bluetooth LE or even Wi-fi might be used around the "smart" house or within a limited range, the battery limitations of the later and the range limitations of the former mean it is unlikely that these standards will form the backbone of a IoT network.

For IoT there are a number of competing radio standards, e.g. LoRa and SigFox, both are long range and provide the ability to build nodes that are very low-power, with a potential battery life of 2 or more years, while providing a long range, often in access of 10km. A key feature of these standards is they are low-bandwidth, often each message is limited to 100 or so bytes, for SigFox even less. Each standard has its drawbacks but SigFox requires more expensive chipsets for the Gateway side of things, which is not the case for LoRa, and as such this has seen the development of community, crowd sourced, LoRa networks, based on LoRaWAN. One example of this is The Things Network, who community has been developing Gateways, nodes, cloud backends, and software to run on these, all open source, supporting open data and open science. In Bristol we are deploying a LoRaWAN network built on existing wireless infrastructure locations, provided by Bristol Wireless.

In this lecture I will introduce LoRaWAN from a technical perspective, providing examples, and also look at the IoT and LoRaWAN networks from a political perspective.

I will bring a portable LoRaWAN network that we have developed at the University of West of England, mostly for testing radio capabilities but also allowing us to demo LoRaWAN and IoT on the move, and also some example nodes, some of which will be used by the audience. This will demonstrate the use of The Things Network backend infrastructure to provide an internet backend and bring the internet part of Internet of Things. We will provide demos that the audience will be able to interact with during the session and see the results live during the talk.

For years IBM has developed an independent implementation of the Java Virtual Machine which helped foster rapid improvements in the Java ecosystem. Recently, IBM has open sourced language agnostic components such as IBM's JIT and GC technologies as part of the Eclipse OMR project. IBM is actively working to open source the rest of the J9 Java VM as the Open J9 project. I will discuss the different components of the Open J9 VM at a high level and our plans for creating the open source project.

EasyBuild is a framework for building and installing (scientific) software on HPC clusters, implemented in Python and available under the GPLv2 FOSS license. It has served HPC support teams well on standard Linux/x86 systems since 2012.

More recently, interest has grown to also employ EasyBuild on Cray systems, where the Cray Programming Environment (PE) not only provides common tools (compilers, ...) and libraries (MPI, BLAS/LAPACK, FFTW, ...), but also tuned installations of 3rd party libraries like HDF5, netCDF and PETSc. The Cray PE consists of an extensive stack of environment modules, providing a familiar yet complex working environment of users.

To leverage the Cray PE a couple of enhancements had to be made to EasyBuild, including support for using 'external' modules, and defining Cray-specific compiler toolchains. In addition, the way in which EasyBuild deals with environment modules had to be carefully revisited, since standard operations like 'module purge' are not supported by the Cray PE.

This work has led to the use of EasyBuild in production on the largest Cray supercomputer in Europe, the Piz Daint system at the Swiss National Supercomputing Centre.

In this talk, we will outline how Cray systems are different from standard HPC systems, motivate the need for a tool like EasyBuild despite the presence of Cray PE, and show how EasyBuild was tweaked to support reproducible software installations on Cray systems.

We believe this is interesting success story of how FOSS has significantly enhanced the software environment on a multi-million dollar production system.

There's no reason SDR needs to be limited to an elite group of users. There are so many tools out there that allow anyone with some technical background to quickly get familiar with the world of SDR. Depending on your background (Ham radio operator, software developer, wireless researcher, Michelin star chef) you may already know some parts of the big picture, but might be missing others. The last few years, many tools have been created to ease your entry into SDR, and we will give an overview of what they are and how you can quickly get started working with electromagnetic waves. No prior knowledge required!

Assuming you can operate a Linux computer, we will use the following tools to get you started with SDR and GNU Radio: - PyBOMBS - GNU Radio Companion - gr_modtool

sysbench is a benchmark tool that is quite ubiquitous in the MySQL community. It is used by both beginners and huge corporations alike as a quick way to evaluate general system performance, a universal measuring tool to compare configuration or code changes, server releases or server flavors, or as a part of QA process. This session will present new features provided by version 1.0 and explain why they are significant enough to justify the 1.0 number.

There are many considerations when building a large SIP infrastructure. This talk will focus on some of the key challenges and decisions that must be made when designing such a system, and how Asterisk can be deployed as a horizontally scalable application server in such a system.

While there is no right way to build a large SIP infrastructure, there are certainly wrong ways. Often, design decisions have to be made early in the construction of an infrastructure that balance trade-offs affecting performance, scalability, and ease of development/deployment.

This talk will explore these trade-offs and design decisions when building such an infrastructure using Kamailio and Asterisk. This includes investigating considerations surrounding: * Managing SIP location and registration * Call routing * SIP subscriptions and event handling * Communications application development

Debugging in browser, logging at server side, analyzing log files, tracing option, that dumps command and notifications for replay, etc.

NodeMCU is an open hardware IoT platform based on eLua for the ESP8266 microcontroller. It allows creating low-cost projects using Wi-Fi and easy scripting in Lua, which makes it great for making wearables, for example. In this talk I'll give an introduction to the platform, show how I built an audio reactive graduation dress and share the materials to get you started on your own wearable project. This talk is ideal for beginners to hardware hacking or Lua enthusiasts looking for project inspiration.

Open source license compliance has become more complex as time progresses. Using open source tools and open standards (SPDX), we should be able to make it easy to comply with the terms of the licenses specified in the code, and not require expensive proprietary technologies. This talk will outline some steps that will help to make license compliance more transparent, and with automation, make it easier to fulfill the obligations.

Using an openly developed standard (SPDX), and open source tooling it is now possible to generate accurate summary information for a project with open source tools, that can be shared with those that use the project. Software development today builds thousand of open source components that developers have shared, tools permit composition of new interfaces from code from many sources, conveying the licensing information hasn't always been a priority for developers, and as a result there's a fair amount of ambiguity out there that needs sophisticated proprietary tooling to decipher the actual licenses in effect. By leveraging automation to generate this information when a project builds, it ensures that the intentions of the authors are accurate and can easily be respected.

This talk will overview the problem scope and then propose some open source tools that can help start the automation part using open standards to improve the transparency of the information.

With the advent of modern package managers for scientific applications (EasyBuild, Spack, etc.) automated building of large amounts of software is becoming easier, quickly giving rise to issues related to life cycle management of applications. This makes tracking the applications and libraries that actually get used considerably more important. Existing solutions (module load hooks, launch wrappers) do not account for user-built software, are hard to deploy or produce inconclusive results.

OGRT enables the tracking of jobs on a cluster with process-level granularity and without discernible performance penalty. It tracks used shared libraries, environment variables and loaded modules at the moment of process execution. It also supports watermarking executables and shared objects and reading those watermarks out of memory at runtime. Gathered information is collected and shipped to various backends.

OGRT aims to be a versatile tool, which can be used to:

• provide a census of used software (including user-built)
• troubleshoot problems with programs picking up unexpected shared libraries
• retroactively inform users about buggy libraries
• overlay process-level data onto existing job monitoring tools
• contribute to reproducibility of application runs

This presentation will give an overview of the design and implementation of OGRT, as well as demoing some of its capabilities when plugged into an Elasticsearch backend.

Writing a functional DPDK application from scratch

A talk to take a user from a basic understanding of the Data Plane Development Kit (DPDK), through writing a simple but functional forwarding application.

This is a presentation to introduce users to the Data Plane Development Kit (DPDK) a set of cross platform open source libraries and drivers for fast packet processing. We will take the user through the steps of building up a simple but functional packet forwarding application, and some tips, tricks, and best know methods of writing an efficient and performant DPDK application.

The talks will be approximately 30 mins each (including 5 mins for questions).

Currently the LibreOffice help system is based on a technology developed circa 2005, and uses the internal Writer - Web module to display its contents. This presentation introduces our efforts to bring the LibreOffice Help system into a modern 2017 technology, preserving our legacy contents and l10n processes.

Introduction

Currently the LibreOffice help system, here forth called HC2 is based on a technology developed circa 20051, and uses the internal Writer - Web module to display its contents. HC2 uses a combination of XML and XLST technology to display contents in Writer/Web and is historically bounded to HTML version 3.2 . As a consequence, the HC2 misses multimedia resources such as videos, animations as well as a modernized concept of CSS and Javascript for better user experience.

Further, the HC2 XML schema (XHP) requires special tools (HelpAuthoring) for editing its contents and a simple inspection on the schema indicates most of its elements are now part of W3C standard HTML5, turning XHP almost obsolete. Current help authoring tools are buggy and requires steep learning curve for the unskilled volunteers.

History of LibreOffice XML Help

LibreOffice Help System was designed and implemented in 2005 by SUN Microsystems ant the times where the "Browswer war" raged and no standard published by W3c was adopted in full by the major browser players. The WWW hijack by major corporations was played in the browser battlefield, twisting specs and invalidating page rendering to build fences around browsers and servers and creating silos of web display technologies;

SUN Microsystem adopted an internal only solution, with a A specific XML (XHP) to hold contents and navigation and an internal browser (Writer Web), that beared a resticted HTML 3.2 specification, together with a C++ wrapper to create index and proper calls

2017 issues for Help System

The current (2005) help system is in a state that is is complex edit/update contents, hard to test and visualize results. There is no rich text available except an authoring extension to LibreOffice that uses Writer as rich text editor but has several issues in exportng and importing xhp files. To use this extension features is as hard as learning XHP itself and as hard as to attempt to edit content with a simple text editor as vim or emacs.

Furthemore the rich text authoring is bounded to the current XHP schema, doubling the effort when it comed to evolove XHP, because the tools must follow the new schema.

The current HTML 3.2 implemetation with LibreOffice Writer / Web rendereing engine, is also bounded to simple images and text, and no video nor another multimedia resource is avalable for the user.

General requirements

The new help system for LibreOffice must support important requirements

It must preserve legacy contents, composed into thousands of XHP files covering all 6 LibreOffice modules and an internal user guide.

It must also preserve the dozens of translations done on these legacy XHP files and the translation process must be ideally preserved or incur in the least perturbation possible.

It must use open, royalty free standars of web technologies, supoort all major browsers of 2017, OS independent.

It must be of easy access, low entry barrier for newbies, volunteers an have support of ease of use editing tools.

It must be perfectly handled by git version control

It must work Off-line and on-line

Strategy

The strategy of the project is in 2 pieces

1) Progressively phase out XHP and phase-in HTML5

HTML5 is a serious candidate to deserve our efforts to bring back our hep content into a general purpose rendering technology, suport moder CSS, javascript, other companion technologies

2) Develop a micro javascript server capable of

• Display the correct help page required by the LibreOffce applicaiton
• Use most of the resources such as navigation history, bookmarking, caching incluced in any major browser
• Handle indexing and searching text among pages
• support XHP and HTML simultaneously

Demo

We will demo where we are at the moment

Concusions

Part of the cost of a technology adoption is its capability to be quickly absorbed by its target audiences. Documentation and help systems plays a key role for the adoption of LibreOffice not only in the home but also in the corporations. Having a dynamic and rich help content that can make users feel the better experience in seeking help is a key step LibreOffice project is taking to inclrease its popularity. The project described here is our current status and will be real very soon.

Valgrind and its different tools are providing a rich set of functionality to track memory problems such as dangling pointers, memory leaks, race conditions, etc.

In this talk, we will describe some old and new features that help to understand what happens in your application. Among others, we will give a demo and/or discuss:

• how to use valgrind with your application specific memory pool

• how to (interactively) ask Valgrind to describe a piece of memory

• some heuristics used by Valgrind to reduce the number of 'possibly lost' leaks with C++ code

• ...

We will discuss more in detail the concept of execution trees, which will be available in the next Valgrind release. An execution tree associates stack traces of your program with some data. Execution trees allow Memcheck and Helgrind to provide a memory profile of your application. We will show how such an execution tree memory profile can be visualised using tools such as Massif visualiser or kcachegrind.

Presentation of the original vision of the Twitter Stream Importer, from start to current situation with "experience feedback". If possible showing a demo real-time and "open discussion" about improvement on going, visualisation usage etc...

Since some years now, the particularity of Twitter is to be "reactive" or real time compare to other Social Network.

The massive stream of data generated by some events (going from Tv shows to more serious event) can't be digested with traditional tools (Twittdeck etc...). The visual representation of a twitter activity could help to reveal insights on a running topic. Graph allows to contextualize and visualise the interaction between users and thematic within this topic.

To do that, the Twitter Stream Importer brings tools to start tracking a topic and visualise data with different "Network logic" that act like a particular projection of the data. The integration within Gephi then, makes easy to use the integrated tools (statistics, filter, exports) to works easily on you subject.

We will see what are the main concept, what are the pro and cons and the following evolution of the plugin.

The Internet of things (IoT) is expected to connect billions of devices. The demand for an open IoT platform is increasing to enable and accelerate the development of cross-domain/cross-vendor use cases and face the accompanying challenges like connectivity with a wide range of heterogeneous protocols and large scale messaging. Eclipse IoT on top of Cloud Foundry is a promising software stack for this goal. However, it will only be successful if it is widely adopted. I will show you where we are today and we can find out together where to go tomorrow.

It is expected that in the next years billions of devices will be connected to the internet of things (IoT). Many of them will interact with cloud-based solutions to provide additional services on the devices or in the web. To bring IoT to the next level technologies for supporting cross-domain/cross-vendor solutions are needed. There is already a lot FOSS available to provide a technological base for building IoT solutions (e.g. Cloud Foundry). However, on top of it, software is needed for the connectivity challenges, support of domain-specific protocols, large scale messaging and device management and integration with existing infrastructure. Eclipse IoT aims to address these needs and provide an IoT framework that makes IoT development fast and simple. However, such an IoT platform can only be successfull if it is widely adopted. No-one can do I(o)T alone. I will show you where we are today and we can find out where to go tomorrow. Come and join us!

This presentation will provide guidelines how to create an open source hardware add-on board for the most popular single board computer Raspberry Pi using free and open source tools from scratch. Specifications of Raspberry Pi Foundation for HAT (Hardware Attached on Top) will be revealed in details. Leon Anavi has been developing an open source Raspberry Pi HAT for IoT for more than a year and now he will share his experience, including the common mistakes for a software engineer getting involved in hardware design and manufacturing. The presentation is appropriate for anyone interested in building entirely open source products that feature open source hardware and open source software. No previous experience or hardware knowledge is required. The main audience are developers, hobbyists, makers, and students. Hopefully the presentation will encourage them to grab a soldering iron and start prototyping their DIY open source device.

Raspberry Pi is the most popular single board computer among hobbyists and students. In 2014 Raspberry Pi Foundation released a specification for add-on boards called HAT (Hardware Attached on Top). Nowadays we are capable of making our own open source add boards following these specifications. In this presentation, Leon Anavi will share his experience in designing an open source hardware Raspberry Pi HAT and developing open source software for it using only free and open source tools such as KiCAD. Leon has been working on his Raspberry Pi HAT as a hobby project in his spare time for more than a year. In November 2016 his open source Raspberry Pi was successfully crowdfunded through IndieGoGo. Now he will explain the challenges and the common mistakes for a software engineer getting involved in hardware design and manufacturing. The presentation will reveal details about the technical specifications of Raspberry Pi HAT, the life cycle of entirely open source project and will provide getting started guidelines. The presentation is appropriate for anyone interested in open source hardware and open source software development. Previous experience or knowledge about hardware design is NOT required. Attendees can expect details about Raspberry Pi HAT technical specification, embedded Linux software development tips for Raspberry Pi, guidelines for hardware design and low cost manufacturing of prototypes or small volume PCB. This presentation will help software developers, hobbyists and students better understand the value of open source hardware and hopefully it will encourage them to a get a soldering iron and start prototyping add-on boards for their favorite Raspberry Pi. The presentation will be also useful to people interested in the concept of entirely open source projects that integrate open source hardware and software created with free and open source tools.

To publish it's documentation, SUSE has developed not only a comprehensive Open Source toolchain to create and publish documentation but also an open workflow that allows community and partners to provide feedback and contribute. These tools and processes can easily be adopted by other projects to write high quality software documentation.

SUSE has been around as Linux vendor for a long time and from it's early days onwards, delivered not only software but also the documentation to use it. In fact, SUSE is not only writing the documentation for it's own distributions but for upstream projects like OpenStack as well. Over time, the SUSE documentation team has developed not only a comprehensive, completely Free and Open Source toolchain to create, edit, manage, and publish documentation but also an open workflow that allows community and partners to provide feedback and contribute. These tools and processes can easily be adopted by other projects to write high quality software documentation, everything from a man page to a reference guide.

In this talk, Christoph will introduce the complete SUSE/openSUSE documentation workflow and tool chain. It will cover both the technical details like formats, tools, or branching model and the organizational aspects such as the feature planning and tracking, distribution of work and feedback process.

How do you integrate containers in your IaaS? In a VM based IaaS environment, introducing containers can be a painful experience. Most likely you end up running containers inside VMs to reuse existing infrastructure, or you start dividing your data-center into a container- and a VM-world. Either way, you have two management solutions and non optimal resource management. But what if we put VMs inside containers? Would such a copernican revolution give us some benefits? This talk covers our research around using Kubernetes as a virtual machines cluster manager.

How do you integrate containers in your IaaS? In a VM based IaaS environment, introducing containers can be a painful experience. Most likely you end up running containers inside VMs to reuse existing infrastructure, or you start dividing your data-center into a container- and a VM-world. Either way, you have two management solutions and non optimal resource management. But what if we put VMs inside containers? Would such a copernican revolution give us some benefits? This talk covers our research around using Kubernetes as a virtual machines cluster manager.

First we will briefly look into what a typical container and a typical VM is. Then we will look into the details on how resource and device limitations are enforced on VMs. In our research we used oVirt, so comparing its host side stack (VDSM/libvirt/QEMU/systemd) to Kubernetes container host side stack (kubelet/docker/rkt/systemd/cni). At the end we will have a better understanding of the differences and overlaps, and can therefore consider how to manage Pet-VMs and containers in the same cluster, managed by kubernetes.

After introducing the Kinto project I am working on, I will explain why push notifications can be useful in the web environment and how I integrated the web push API in Python in Kinto as well as on the client using service workers.

What is Kinto? Kinto is a minimalist JSON storage service with synchronisation and sharing abilities. It is easy to use and to self-host. Kinto is used and developed at Mozilla and released under the Apache v2 licence.

Why use Kinto? Kinto lets you focus on writing great user-facing interfaces and takes care of storing, sharing and synchronizing your application state with multiple devices or users. It is often a big deal for developers to develop web APIs that handle CORS, are secure, respect users privacy by supporting encryption when building applications that work offline, store data remotely, and synchronise across devices. Existing solutions either rely on big corporations that crave user data, or require a non-trivial amount of time and expertise to develop a new server for every new project. We want to help developers focus on their business logic and value proposition, and we don’t want the challenge of storing user data or developing backends to get in their way. The path between a new idea and deploying to production should be short! Also, we are firm believers of the fact that data belongs to users, and not necessarily to the application authors. Applications should be decoupled from the storage location, and users should be able to choose where their personal data is stored. The backend can often be universal, generic and reusable. We envision mutualisation of services and self-hosting: the backend is deployed, secured and scaled only once for several applications, which is amazing!

Why Web Push? Push notifications allow users to opt-in to timely updates from the sites they love and allow you to effectively re-engage them with not only customized and engaging content but also enable real time interactions with other users of the application, realtime updates and real time data sharing through websockets With Web Push, the notification payload is encrypted by the server sending the notification which makes it really secure and privacy aware. Web push is a browser API feature so that you don't need to pay or to deploy anything on the server side to have it working out of the box.

HOW TO PUSH:

What is a service worker? A service worker is a worker working in the background of your browser that can handle events for a given origin and path. It takes the form of a JavaScript file that can control the web page/site it is associated with. They will also allow handling of push notification events and background sync APIs. Service workers keep working after the page or website is closed and between browser restarts.

How to use push notifications? On the client side, it means to setup a service worker and to get a subscription for the user browser. The resulting PushSubscription includes all the information that the application needs to be able to send a push message: an endpoint and the encryption key needed for authenticating and encrypting the data.

What is the Kinto Push Service? In the Kinto use case, all users of the same web application will probably want to receive notifications informing them about the creation, updation or deletion of a collection or a record from another device. Each device will have its own subscription endpoint and encryption key and the payload will need to be sent to each one of them. My project was about creating a service that can handle subscriptions management and notification broadcast for a given channel. When the web application starts, it will start a service worker that will be configured to receive push notification and sent them back to all the active browser pages of the web application. The application will call the push service to register the push subscription on some events. A Kinto plugin will be triggered each time the application collection changes and it will call the ‘send the notifications’ on the push service channel. The push service will get the notification, encrypt it and publish it to all the subscriptions for that user.

Role of the PushAPI: - So, once you’ve got the permission for notifs, registered the service worker and suscribed to push notifs! Congratulations, major breakthrough has been achieved already. - Send the endpoint associated with the subscription and generate a client public key (PushSubscription.endpoint and PushSubscription.getKey()) to the server so it can send push message when required. - Using the Channel Messaging API set up a new message channel (MessageChannel.MessageChannel()) to communicate with the service worker and by calling Worker.postMessage() on the service worker, in order to open up the communication channel. - On the server side, store the endpoint and any other required details so they are available when a push message needs to be sent to a push subscriber. In a production app, it needs to be made sure that these details are kept hidden, so malicious parties can't steal endpoints and spam subscribers with push messages. - To send a push message, an HTTP POST is sent to the endpoint URL. The request must include a TTL header that limits how long the message should be queued if the user is not online. To include payload data in the request, it must be encrypted (which involves the client public key). Encryption is a complex process, so we can choose to use libraries which handles all the hard work.

Join us as we demonstrate how Mozilla are using Selenium to test Firefox by extending the WebDriver specification.

Selenium is a popular tool for testing websites across multiple browsers, and when combined with Mozilla's implementation of the WebDriver specification, it becomes possible to interact directly with Firefox itself. In this session, we'll show a simple approach to writing tests using Selenium in Python, and then demonstrate how we're taking this further to replace our existing functional UI tests for Firefox. By using Selenium, we're hoping to make contributing to these tests much easier for our community, and by pushing the tools to their limits we'll also make them rock solid.

Thermostat is a monitoring and management tool for Java deployments, allowing users to measure and monitor a host of different performance aspects of their Java applications. Available metrics range from raw CPU and memory usage to operation of the Garbage Collector and JIT compiler through to thread activity and method call/heap profiles. Thermostat provides a GUI view of activity of local and distributed JVMs in a live-view or, alternatively, offline for after-the-fact analysis.

What Thermostat cannot do on its own is track events and record statistics that are specific to a given Java application, at least not unless the application co-operates with it, for example by publishing JMX statistics that Thermostat can read, persist and display in its GUI. However, that's about to change thanks to work Thermostat developers have been doing to integrate Byteman into Thermostat.

Byteman is a tool which can be used to modify the behaviour of Java programs by injecting extra Java code almost anywhere in the program. You don't need to recompile your program or even prepare it in advance in order for this to work. You can specify changes to the program on the command line but, what is more amazing, you can actually use Byteman to change the way a program runs after startup while it is still running.

In this talk we will show how Thermostat can collect and visualize metrics with Byteman's help in order to better understand a specific performance issue in a Java application.

The state of SDR, and free/open SDR in particular, is interesting. In some cases, SDR research and progress has been declared dead, implying that there is nothing left to research or develop. Practical usage of SDR tells a different story, though, and users of SDR products run into all sorts of issues every day.

In this panel, we would like to discuss with the audience what the top issues are that SDR frameworks need to solve in the near future -- be they technical, legal, political or anything else.

What are the top 3 items that the realm of Software Defined Radio needs to figure out? In this panel, we invite some experts as well as the entire audience to discuss this question. We shall discuss technical challenges (if there are any) as well as legal and political challenges. Does free/open software radio have any different questions to tackle? If we were to attend a technical conference in the near future, what would be the most mind-blowing thing we could present? Will there be more, competing frameworks going forward, or will they consolidate? These and many more questions shall be the topic of this year's SDR panel.

Jitsi offers seamless and secure multiparty video conferencing while being 100% Open Source. Come and see what's new in Jitsi land! This talk will dive into the latest developments in the Jitsi Videobridge such as simulcast support and the new React Native based Jitsi Meet, the video groupchat client which just went mobile.

Jitsi started out as "SIP Communicator" back in 2003 and has been in the forefront of Real Time Communications ever since. One of Jitsi's biggest innovations was the introduction of the videobridge, which made video groupchat possible. Lately the Jitsi team has been focused on adding new features to the videobridge such as simulcast along with the development of a React Native based client for mobile platforms. All of this while being secure and 100% Open Source!

GitHub's gh-ost is a MySQL online schema migration tool changing the operational paradigm. It is triggerless, controllable, auditable, and generates a low writeload on the master.

This session describes how gh-ost differs from existing online schema migration tools, and the many perks made available by its design.

gh-ost runs all of GitHub's migrations. It is released as open source and supported by GitHub at https://github.com/github/gh-ost

Even if mruby core works on Windows, any mruby app is may not work if the libraries it depends on don’t compile and run on Windows. Using Rust, we can work towards building an ecosystem that is Windows compatible. This talk walks through building mruby libraries that do that.

Unlike some other languages like JavaScript, Java, or Python, Ruby is not known for it’s ability to run well on Windows. The Windows environment is often treated as a second or third class citizen even though there are many potential users. Part of this is due to Ruby’s strong POSIX oriented standard library. This has mostly been ok since most Ruby applications are hosted and run on UNIX servers.

mruby is a lightweight Ruby that can be linked and embedded inside other applications. Being embeddable means that the runtime host could be Windows. mruby also has no Operating System specific standard library. Since the ecosystem is young, there’s potential for an ecosystem that is Windows friendly. But writing cross platform native extensions in C for mruby is still difficult.

Rust is a modern systems programming language that is fast and built to prevent segfaults and guarantee thread safety. It’s more than just a compiler, it’s a platform that has a great dependency manager and cares about cross compilation out of the box. This makes it a great candidate over C to write native extensions.

In this talk, we’ll go over some basic Rust and how we can integrate this to write mruby libraries that compile on Linux, OS X, and Windows. It’ll dig into not only writing the library code, but also the mruby C API as well as the mruby/Rust binding layer that makes this all possible.

Bareos (Backup Archiving Recovery Open Sourced) is a reliable, cross-network open source software for backup and recovery of data for a large set of operating systems (Linux, Unix, Windows, MacOS). This presentation will give an overview about what Bareos is and how to use its components. It will also highlight the latest stable features and present the roadmap for the next release.

The Bareos project stated in 2010 as a fork of Bacula. Since then, lots of features have been introduced or enhanced, like Python-Plugin-Interface, VMware Plugin, Always Incremental, SCSI Crypto support, bareos-webui ...

This presentation will give a general overview about what Bareos is and how it can be used.

It will highlight some of the unique features, tells what is currently in development and the roadmap for the next releases.

we are modifying Nova kernel to make it support temporal redundancy for user processes running Genode components. Every time a process releases the CPU, we manage to restart it from its last starting point and re-run the same portion of the process code. An practical application of this could be an implementation of a fault tolerant system. At the end of the two executions, one may compare their memory footprints to detect an eventual fault due for example to SEU. We are also interested in the performance penalty this would induce on the overall systems compared to existing redundancy models. In this talk, we will present how Genode components performances are impacted by this type of redundancy. Possible choices and remaining challenges for extending this model for multiprocessor environment will also be discussed.

"But what about the extensions?" can be the death knell for whatever cool new feature somebody tries to implement in LibreOffice, as extensions naturally ask for interface stability. But what about them, anyway? Are they the saviour that brings diversity to our desktops, or are they just a ghostly phantom that stifles innovation? Lets take a look at the extension landscape out there.

I will be discussing recent work by my team to use the Eclipse OMR JitBuilder technology to improve the Lua interpreter performance. I will show the small changes required in the runtime to take advantage of the OMR JitBuilder technology, show the performance improvements and discuss the trade offs of using a JIT.

The Eclipse OMR project consists of a highly integrated set of open source C and C++ components that can be used to build robust language runtimes that will support many different hardware and operating system platforms. The talk will be focused mainly on the Compiler technology and specifically the JitBuilder and how it could be used by the Lua runtime. You can read more about the Eclipse OMR project at https://www.eclipse.org/omr/ and view the code at https://github.com/eclipse/omr. I will make a version of the Lua runtime source code with our changes available so everyone can look through and ask questions or provide feedback.

It is generally assumed that free and open source communities are best served by governance rules that are open and transparent. I will argue that while openness and transparency are necessary, they are not sufficient. Particularly as the number of open source communities governed by trade associations grows, additional principles are necessary such as vendor neutrality, and ensuring a level playing field. This talk will provide an overview of the (often legal) control points that exist in open communities, and various strategies used by corporations to seize them. It will also provide some examples of existing community governance rules which openly and transparently ensure special rights to particular organizations. A few simple governance hacks to help make trade associations better stewards of open communities will also be discussed.

The growing Python data science ecosystem, including the foundational packages Numpy and Pandas, provides powerful tools for data analysis that are widely used in a variety of applications. Typically, these libraries were designed for data that fits in memory and for computations that run on a single core.

Dask is a Python library for parallel and distributed computing, using blocked algorithms and task scheduling. By leveraging the existing Python data ecosystem, Dask enables to compute on arrays and dataframes that are larger than memory, while exploiting parallelism or distributed computing power, but in a familiar interface (mirroring Numpy arrays and Pandas dataframes).

Slides: https://jorisvandenbossche.github.io/talks/2017FOSDEMdask/

Analysis on advantages of using an external node classifier system. Examples on how to ease Saltstack administration with reclass.

The configuration management system are born in order to lower the burden of administering a bunch of servers and to increase the profitability of the work of the system administrator. But what happens with the increase of the administered nodes and the extensiveness of the administration's formulas?

In order to do not get lost into the complexity of rules and exceptions, the life of the system administration could be eased by the adoption of an external node classifier system that could bring clarity and concision.

As example I will show how to easy the administration of a saltstack infrastructure with reclass, a ENC software compatible also with Puppet and Ansible.

Tanker goal is to allow easy batch operations without compromising database modeling. For pandas users, it's like DataFrame.to_sql on steroids.

The Tanker inception is based on two strong observations (not particularly new):

• The object-relation mapping in so called libraries is sometimes source of performance and semantic difficulties, especially with queries involving multiple joins. On the other hand, the relational model is both powerful and simple, and there are no reason not to expose it to the Python world.

• When working with external data sources, we are often faced with the challenge of matching those records with the database content. We have to know which record is new, which has been updated, etc. We also often have to de-normalize content and map it with a (hopefully) well-designed and 3NF schema.

This presentation will show how Tanker answers those two aspects, how it was inspired by existing libraries and how it is currently used in production applications.

The HotSpot JIT compilers use a lot of sophisticated optimization techniques to speed up your Java code. Sometimes, these advanced optimizations are so aggressive that they may eliminate required checks by mistake and therefore suppress expected program errors.

In this talk, I'll briefly introduce Escape Analysis and Intrinsics, two commonly used HotSpot optimization techniques. I'll show how a combination of these two features can optimize away IndexOutOfBoundsExceptions in some corner cases where they are required by the standard and how I fixed this error in recent versions of the OpenJDK.

This talk presents an overview of the Linux kernel's eBPF subsystem and how it integrates into tc (traffic control) and XDP (eXpress Data Path) for providing a high-performance, in-kernel programmable networking data plane. Since the last fosdem, many new eBPF-related features found its way into the Linux kernel. This talk highlights some of the most important advances along with some examples on how this facility can be programmed.

Never before it was so easy and inexpensive to gather, as well as generate, massive amounts of data. Often, data get discretized in space and time, nat­ur­ally leading to multi-dimensional arrays. In fact, arrays play a core role in most domains of science, engineering, and bus­in­ess - generally speak­ing, spatio-temporal sensor, image, time­series, sim­­ul­ation, and statistics data­. This raises the need for flexible, scalable, and open services in replacement of the bespoke silo solutions that have prevailed in the past.

Traditional databases have been successful due to their flexibility (through query languages) and scalability (through manifold optimizations and parallelization in the server) - however, they unfortunately do not support massive arrays. This is being remedied within ISO currently where SQL/MDA ("Multi-Dimensional Arrays") is in an advanced stage, likely becoming adopted in summer 2017. SQL/MDA adds declarative array definition and operations to SQL. Not only paves this the way for powerful services, maybe even more important it allows, for the first time, integrating data and metadata into the same archive, even in one and the same query. As such, SQL/MDA will be a game changer in data services not only for science and engineering at large.

We present the concepts and rationales, as well as the open-source technology rasdaman ("raster data manager") which is serving as the blueprint for MDA.

We have learnt to live with the pain of separating data and metadata into non-interoperable silos. For metadata, we enjoy the flexibility of databases, be they relational, graph, or some other NoSQL. Contrasting this, users still "drown in files" as an unstructured, low-level archiving paradigm. It is time to bridge this chasm which once was technologically induced, but today can be overcome.

One building block towards a common re-integrated information space is to support massive multi-dimensional spatio-temporal arrays. These "datacubes" appear as sensor, image, simulation, and statistics data in all science and engineering domains, and beyond. For example, 2-D satellilte imagery, 2-D x/y/t image timeseries and x/y/z geophysical voxel data, and 4-D x/y/z/t climate data contribute to today's data deluge in the Earth sciences. Virtual observatories in the Space sciences routinely generate Petabytes of such data. Life sciences deal with microarray data, confocal microscopy, human brain data, which all fall into the same category.

The ISO SQL/MDA (Multi-Dimensional Arrays) candidate standard is extending SQL with modelling and query support for n-D arrays ("datacubes") in a flexible, domain-neutral way. This heralds a new generation of services with new quality parameters, such as flexibility, ease of access, embedding into well-known user tools, and scalability mechanisms that remain completely transparent to users. Technology like the EU rasdaman ("raster data manager") Array Database system can support all of the above examples simultaneously, with one technology. This is practically proven: As of today, rasdaman is in operational use on hundreds of Terabytes of satellite image timeseries datacubes, with transparent query distribution across more than 1,000 nodes.

Therefore, Array Databases offering SQL/MDA constitute a natural common building block for next-generation data infrastructures. Being initiator and editor of the standard we present principles, implementation facets, and application examples as a basis for further discussion. Time allowing we will present live demos from services exceeding 20 TB of "datacubes".

openvz containers, how it works and how it looks

We'll talk about how Virtuozzo Linux create lightweight virtual environments - containers, preloaded with the Linux distribution and a given set of applications. In our approach we use a modified version of the package management tools, i.e yum, dpkg, zypper for creating caches and file system images, which need for the fast deployment and for package management in already deployed environments. In this presentation we will look at the advantages and disadvantages of our approach compared to other solutions - such as templates and Docker Lxc.

One of the major challenges for certification in the SIL2LinuxMP project, is to show that Linux does not only define a development process, but also follows it. To this end (and far beyond!) the meta-data of commits to the Linux kernel are analyzed.

The talk covers everything from gathering the data, to distributing it to every one in the project while keeping it the data up-to-date and of course our first analysis results. Each of these phases contain their own set of problems that needed to be considered, leading to a framework called DLCDM (Development Life-Cylce Data-Mining) that is introduced for the first time during this talk.

One of the major challenges for certification in the SIL2LinuxMP project, is to show that Linux does not only define a development process, but also follows it. To this end (and far beyond!) the meta-data of commits to the Linux kernel are analyzed. There are several intended outputs we hope to get out of this analysis, some examples are:

    - Competence of persons involved (IEC 61508-1, 6.2.13/6.2.14)
    - Dependencies amongst developers (Independence of persons doing code
      reviews)
    - Identify patches that did not get enough review (based on patch
      complexity, experience of author, reviews, etc.)
    - Automatic notification of patches in our configuration
    - Bug analysis (based on Fixes: tag)
    - Subsystem dependencies and conflicts

The talk covers everything from gathering the data, to distributing it to every one in the project while keeping it the data up-to-date and of course our first analysis results. Each of these phases contain their own set of problems that needed to be considered, leading to a framework called DLCDM (Development Life-Cylce Data-Mining) that is introduced for the first time during this talk.

Containerised Application technologies like AppImage, Snappy and Flatpak promise a brave new world for Linux applications, free from the worries of shared libraries and dependency issues. Just one problem, this is a road long travelled before, such as in the application dark ages of Win32 applications and DLLs. And it worked out so wonderfully there... Do we risk a future where, like the resurrected dinosaurs of Jurassic Park, this family of applications will break their containment and start eating our users? This session will try to present a balanced argument about the situation, frankly discussing the benefits promised by these technologies, but highlighting the very real issues and risks their widespread adoption could, and in some cases are, already bringing to the table.

The talk with cover the promised benefits of application containers, such as AppImage, Snappy and Flatpak. It will detail the empowerment of developers who use the technologies, the ability for upstream projects to have a much closer role in delivering their software, and the benefits that brings to both the upstream projects and their users. But as a counter to those benefits, the session will detail some of the risks and responsibilities that come with that technology. The complexities of library integration, the risk of introducing new forms of dependency issues, and the transference of responsibility for those issues, plus security, away from the current Distributions delivering upstream projects towards those upstream projects directly. As a conclusion, the session will present some suggestions to upstream projects adopting these technologies to start them down the road of accepting those responsibilities directly, or working more closely with existing Distribution projects to share the burdens these technologies now provide.

A technical talk about the web rendering architectures of today and tomorrow.

MsgFlo is a tool to build systems that span multiple processes and devices, for instance IoT sensor networks. Each device acts as a black-box component with input and output ports, mapped to MQTT message queues. One then constructs a system by binding the queues of the components together. Focus on components exchanging data gives good composability and testability, both important in IoT. We will program a system with MsgFlo using Flowhub, a visual live-programming IDE, and test using fbp-spec.

At the 2014 IoT devroom, we introduced flow-based programming (FBP) for heterogenous IoT systems, using NoFlo and MicroFlo. The programming model worked well for individual devices, but between the devices of the system our solution caused too tight coupling. When we realized this, we decided to build Msgflo, which reuses many of the same concepts and tools.

In MsgFlo each process/device is an independent participant, receiving data on input queues, and sending data on output queues. A participant do not know where the data comes from, nor where (if anywhere) the data will go. This strong encapsulation gives good composability and testability. MsgFlo uses a standard message queue protocol (MQTT or AMQP). This makes it easy to use with existing software. As each participant is its own process and communicate over networks, they can be implemented in any programming language. Convenience libraries exist for C++, Python, Arduino, Node.js and Rust. On top of the message queue protocol, a simple discovery mechanism is added. For existing devices without native Msgflo support, the discovery messages can be sent by a dedicated tool.

We have used Msgflo in a handful of real-life deployments, and will demonstrate building a simple stand-alone IoT system.

JsSIP allows you to create WebRTC applications using SIP within your browser.

The talk will go through the beginning of its development along with the standarization process of the WebSocket as a transport for SIP, the use cases, the present and the future of JsSIP.

You’ve deployed automation, enabled automatic master failover and tested it many times: great, you can now sleep at night without being paged by a failing server. However, when you wake up in the morning, things might not have gone the way you expect. This talk will be about such a surprise.

Once upon a time, a failure brought down a master. Automation kicked in and fixed things. However, a fancy failure, combined with human errors, with an edge-case recovery, and a lack of oversight in automation, lead to a split-brain. This talk will go into details about the convoluted - but still real world - sequence of events that lead to this disaster. I will cover what could have avoided the split-brain and what could have make things easier to fix it.

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

Presentation of an investigation into how Python's RDFLib and SQLAlchemy can be used to leverage PostgreSQL's capabilities to provide a persistent storage back-end for Graphs, and become the elusive practical RDF triple store for the Semantic Web (or simply help you export your data to someone who's expecting RDF)!

QEMU is an open source machine emulator and virtualizer written in C. Over time it has evolved multiple interfaces to interact with the outside world, and multiple internal APIs and abstractions to model and keep track of data. The talk will be a review of some of the challenges and trade-offs involved in making those abstractions work together.

Over time, QEMU has evolved multiple interfaces to interact with the outside world (command-line interface, configuration files, its monitor protocol), and multiple internal APIs and abstractions to model and keep track of data (including configuration, device hierarchy, device state, etc).

Understanding the goals and limitations of each of those abstractions and finding their way through the long list of acronyms (qdev, QOM, QAPI, QMP, VMState, QemuOpts, QObject, etc) can be intimidating to developers not familiar to QEMU. Sometimes each of them have conflicting world views, different goals and constraints, and interaction between them generate interesting challenges to developers working on QEMU. The talk will be a review of some of the challenges and trade-offs involved in making those abstractions work together.

The target audience are developers that want to get more familiar with QEMU internal APIs, or see what are the lessons learned (or not learned) from them.

Short presentation of LizardFS with example Setup. Especially focused on how easy it is to setup, use, manage, extend and shrink.

mediasoup is a WebRTC SFU (Selective Forwarding Unit) for Node.js that allows applications to run multiparty video conferencing with browser and mobile devices in a multi-stream fashion.

Rather than being yet another standalone media server, mediasoup is a Node.js library/module which can be easily integrated within existing applications.

mediasoup exposes both, the ORTC API and the WebRTC API (same as in browsers), allowing the application to program multiparty video conferencing via JavaScript. mediasoup is minimalist, it just focuses on media handling. It does not provide, nor it mandates, a specific network signaling protocol.

The talk will expose the technology behind mediasoup, the API it exposes, and a demo application the assistants will be able to join.

In this talk, we will present the latest improvements done for ARM64 and MIPS64 platforms in LuaJIT. The talk will cover challenges related to new GC64 mode, as well as arch-specific issues.

Up to recently, the only 64-bit architecture that LuaJIT supported was x86_64 and in the latest official release it had limits with addressable memory. In the meantime, new GC64 mode was finished which enabled LuaJIT to address 47-bit address space. ARM64 and MIPS64 ports were done on the top of the new GC64 mode. We will discuss the current status of these ports and point out some pending issues that could cause problems in today's software that uses LuaJIT. The talk will also be useful to those interested to port LuaJIT to another architecture.

Redox is an attempt to make a complete, fully-functioning, general-purpose operating system with a focus on safety, freedom, reliability, correctness, and pragmatism.

So how do we get there? By keeping the kernel minimal, both in terms of syscalls and in terms of size. By writing the code in Rust, a modern, memory-safe and type-safe systems programming language. By maintaining minimal privileges, through a general capability-based system.

Redox is an ambitious project, but it already runs on real hardware. Let's take a look.

OpenOffice Basic is cool. It can manipulate everything in your document, spreadsheets and slides. It helps you to create complicated reports automatically. But OpenOffice Basic is not cool. It lacks everything a modern hardcore developer needs: Personal favorite text editors, version controls, source repositories, etc. OpenOffice Basic macros are created and edited only with Basic IDE, and stored in some hidden place in your hard disk, not in the source form but in XML. They cannot be managed with modern development tools like svn, git, different text editors, and cloud storage backup.

What if there is a tool that let you work off-line, out of the OpenOffice Basic IDE box, with your favorite text editor, on anywhere on your hard drive? That's why I wrote obasync to do this job: Synchronize your local Basic macro sources with OpenOffice Basic storage. It frees me from Basic IDE and I can apply every source code development tools now.

The Rust project has become a large software development project. To better understand how it is being developed, a software development analytics dashboard has been deployed for it. This dashboard tracks most of the public data about Rust development, and allows to visualize, drill down and understand that data. The talk will present this dashboard, and how to use it to learn about the details of Rust development processes and community. It will also present some interesting data obtained from it.

The Rust software development dashboard visualizes data obtained from some systems used to support Rust development: git, GitHub, StackOverflow... The data related to Rust is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard allows not only to browse the data, but also to drill down and play with it. This way, any person interested in how Rust is being developed can have both an general overview, or very detailed views of the community and processes involved. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Rust Development Dashbard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

The talk will present the different kind of information that can be obtained from the dashboard, and how to interact with it for finding any detail of interest. Several specific aspects of Rust development will be presented as well, so that people attending may expect to finish the talk with a better understanding of how Rust is being developed. The talk will also provide hints on how to exploit the data behind the dashboard to obtain specific information.

We present the pure functional array language, Futhark, along with its optimising GPU-targeting compiler. Of particular focus are the language tradeoffs necessary to ensure the ability to efficiently generate high-performance GPU code from a high-level parallel language. We also demonstrate (nested) data-parallel array programming, a programming paradigm that enables concise programming of massively parallel systems. We show how Futhark code can be easily integrated with larger applications written in other language. Finally, we report benchmarks showing that Futhark is able to match the performance of hand-written code on various published benchmarks.

GPUs and other massively parallel systems are now common, yet programming them is often a painful experience. Languages are often low-level and fragile, with careful hand-optimisation necessary to obtain good performance. The programmer is often forced to write highly coupled code with little modularity. The high-level languages that exist, often functional in nature, are often insufficiently flexible, or poor performes in practice. We present our work on a programming language that seeks a common ground between imperative and functional approaches.

Futhark is a small programming language designed to be compiled to efficient GPU code. It is a statically typed, data-parallel, and purely functional array language, and comes with a heavily optimising ahead-of-time compiler that generates GPU code via OpenCL. Futhark is not designed for graphics programming, but instead uses the compute power of the GPU to accelerate data-parallel array computations. We support regular nested data-parallelism, as well as a form of imperative-style in-place modification of arrays, while still preserving the purity of the language via the use of a uniqueness type system.

The Futhark language and compiler is an ongoing research project. It can compile nontrivial programs which then run on real GPUs at high speed. The Futhark compiler employs a set of optimisations (fusion, flattening, distribution, tiling, etc) to shield the programmer from having to know the details of the underlying hardware. The Futhark language itself is still very spartan - due to the basic design criteria requiring the ability to generate high-performance GPU code, it takes more effort to support language features that are common in languages with more forgiving compilation targets. Nevertheless, Futhark can already be used for nontrivial programs, and has been used to port several real-world benchmark applications, with performance comparable to original hand-written GPU (OpenCL or CUDA) code.

Futhark is not intended to replace existing general-purpose languages. Our intended use case is that Futhark is only used for relatively small but compute-intensive parts of an application. The Futhark compiler generates code that can be easily integrated with non-Futhark code. For example, you can compile a Futhark program to a Python module that internally uses PyOpenCL to execute code on the GPU, yet looks like an ordinary Python module from the outside.

gcc/glibc support fortification of some functions by defining FORTIFYSOURCE. This inserts some compile and runtime buffer overflow checks for selected glibc functions. These checks have no or very little runtime overhead and work on the object level (the compiler provides/proofs the size of the object buffer size). valgrind memcheck provides similar memory buffer overflow checks. These checks don't need any compiler help (you won't have to rebuild your code). But they have a much higher runtime overhead. They also work on a different level. valgrind memcheck doesn't know anything about the objects the user is manipulation but has knowledge of all memory blocks allocated. Lets explore how these different mechanisms work and how we can make them work better together.

Getting a new Linux appliance with every commit you push sounds awesome but impossible, right? Not with the Open Build Service, the Free Software build and distribution system which powers openSUSE, ownCloud and Tizen! Usually a lot of manual work is necessary to create your custom Linux appliance, but the Open Build Service abstracts all the complicated technologies and makes this task as easy as pie. In this talk, we will show you how we plug several open source technologies together to create Linux appliances in a fully automated, continuous integration cycle.

Getting a new Linux appliance with every commit you push sounds awesome but impossible, right? Not with the Open Build Service, the Free Software build and distribution system which powers openSUSE, ownCloud and Tizen! Usually a lot of manual work is necessary to create your custom Linux appliance, but the Open Build Service abstracts all the complicated technologies and makes this task as easy as pie. In this talk, we will show you how we plug several open source technologies together to create Linux appliances in a fully automated, continuous integration cycle.

Starting with a commit to your favorite version control system, the OBS will build a ready-to-use image of an operating system for you automatically, using the power of KIWI. And to finish the continuous integration cycle, openQA will run automated tests to make sure your appliance still works as expected.

If you still manually build and test your Linux appliances, this talk is for you!

This talk demonstrates that programmability and performance does not require user space networking, it can be achieved in the kernel by generating BPF programs and leveraging the existing kernel subsystems. We will demo an early prototype which provides fast IPv6 & IPv4 connectivity to containers, container labels based security policy with avg cost O(1), and debugging and monitoring based on the per-cpu perf ring buffer.

The talk would aim about making an introduction to open source intelligence automation tools(OSINT) developed in Python, commenting the process we can follow to obtain, analyze and exploit public information in social networks and public servers.The final objective is obtain the maximum possible of knowledge in the context we are auditing.

The talking points could be:

-Introduction searching information from multiples sources with OSINT tools. -OSINT tools developed with python for extracting public information from servers and domains. -Advantages and limitations these tools from the user point of view. -Comment how these tools are developed and the main modules used in their development.

Some of the tools to comment are:

-Censys and Shodan Python API as search engine server information. -SpiderFoot and recon-ng as a tools for extracting information from multiple sources and automate the footprinting process. -the Harvester as Python script for extracting emails and hostnames in a particular domain. -Osrframework and Maltego OSINT visualisation tool -Libraries and modules for collecting information from Tor and ZeroNet networks -Tinfoleak and Tweepy as Python scripts for data extraction on twitter. -FullContact API for obtain social networks profiles associated with an email address.

JESD204B is a industry standard for interfacing high-speed converters (ADC, DAC) to logic devices (FPGA, ASIC). This presentation will give a introduction to the JESD204B standard which is gaining increasing adoption in SDR solutions to connect the RF-fronted device to the processing device.

JESD204B is a industry standard for interfacing high-speed converters (ADC, DAC) to logic devices (FPGA, ASIC).

Software-defined-radio solutions follow a trend of ever increasing channel bandwidth and diversity (e.g. MIMO). Another trend is the transition from zero-IF to direct-IF, which bypasses the analog modulator and samples the full spectrum up to the desired signal. Both of them require additional data throughput rates which can reach the limits of more traditional interfaces like CMOS or LVDS. The JESD204B standard has been designed to overcome these restrictions and allow higher throughput data rates between the converter and the logic device. It is as such not surprising that to accommodate the increased data rate demands of such solutions JESD204B is often adopted, both for discrete as well as integrated RF designs.

In addition to specifying the physical layer the JESD204B specification also has a protocol layer defining data mapping and encoding as well as standard methods for commonly needed features like data integrity checks, multi-chip synchronization and deterministic latency.

This presentation will provide an introduction to the JESD204B standard in the context of software-defined-radio explaining how the different layers inside the JESD204B standard interact, giving developers a understanding of how to setup and configure a JESD204B system.

6LoWPAN enables, as the name implies, IPv6-communication over Low-power Wireless Personal Area Networks, e.g. IEEE802.15.4. A lot of resources are available to allow 6LoWPAN over IEEE802.15.4, but how can one extend the 6LoWPAN feature-set for the use with other link layer types? This talk will cover the details about a generic implementation that should work with every link layer type and how one can provide support for ones own custom wireless network. The goal is to give quite a technical and detailed talk with finally a discussion about when 6LoWPAN is actually useful and when is it not.

Last year, as a summer project, I've implemented a generic 6LoWPAN adaption layer into picoTCP, an open source embedded TCP/IP-stack developed by Altran Intelligent Systems, with an eye on the IoT. I've made an effort to make the adaption layer as generic as possible allowing it to be easily expandable with new link layer types and topologies. The layer should also be able to allow multiple link-layer extensions, for post-network-layer processing. This could be used for mesh-under routing, link layer security, whatever you want. This talk will cover how one can take advantage of these features and caveats that come with it. I also have my personal thoughts on 6LoWPAN and I would like to share them with you at the end of the talk.

Most database attackers are after your sensitive data. But there's no easy way to detect them accessing the data since your application will be accessing it too. This is where honey-potting can be really useful. This session will demonstrate a neat way to do honey-potting using nothing but existing MySQL tools.

We will demonstrate how one can set up a "honey-pot table" and set alarms around it in such a way that, when the table is accessed the server will take decisive actions to limit the session's access and warn the DBA. We will do with nothing but stock tools available for the MySQL 5.7 server.

A rough overview on the pretty Easy privacy (p≡p) project:

p≡p stands for pretty Easy privacy. The idea is to ease the use of well-known and established end-to-end cryptographic tools for already existing and widely used written digital communication channels, starting with email and radically easing adoption of OpenPGP-compliant encryption for it. Later on, XMPP-based communication channels (using e.g. OTR) and others will be added, with the ultimate goal to route all messages through GNUnet, a secure peer-to-peer framework, which doest not just protect message contents, but also metadata.

Basically, p≡p's proposed and (to some degree) already implemented protocols automate the steps taught to users at CryptoPartys, from which the project emerged.

p≡p supports multiple platforms (e.g., Android, *BSDs, GNU/Linux distributions, iOS, MacOS X and Windows), multiple programming languages and environments (e.g., C#/COM, C++/Qt, Java, JavaScript, Objective-C/Swift and Python) and will provide easy access to multiple crypto technologies through an abstract API which doesn't require application developers to have in-depth cryptographic knowledge, i.e. the p≡p engine takes care of the details. The focus for now is to have OpenPGP-compatible communications for email widespread, using already existing crypto tools like GnuPG and a NetPGP fork (needed for iOS).

p≡p's core parts (the p≡p engine and the adapters / bindings for different programming languages) are owned by the Swiss-based, tax-free p≡p foundation and held under the GNU GPL v3 license alongside with the p≡p trademarks. The foundation is run by privacy activists from Germany and Switzerland. Any project willing to implement p≡p will be supported, especially in the Free Software world. For trust and security reasons, the p≡p foundation requires projects to let their p≡p implementations code audited by a trustworthy independent firm upon every release, if they want to use the p≡p trademarks, so as to make sure there are no backdoors in officially endorsed p≡p end-user software. The p≡p foundation, for cases where the money for such undertakings is not available, is willing to either finance the code audits itself or to organize such funding at least.

p≡p foundation has close cooperations with the Enigmail (Enigmail 2.0 will be Enigmail/p≡p), the GNUnet project and soon ISOC Switzerland (ISOC-CH).

But there's also extensive exchange with other groups like the CCC (particularly in Switzerland), the FSFE, the Mozilla Foundation (Mozilla Thunderbird in particular), The Reva & David Logan Foundation and the GnuPG project.

The Lightning Talk will be quite short: 10mins. 5mins will be reserved for (hopefully) lots of questions. :) (For further and more detailled questions, just visit us at the GNU Taler / p≡p foundation stand in building K, level 1, group A.)

The speaker, Hernâni Marques, is council member of the p≡p foundation.

(Note that this talk was originally going to be presented by Volker Birk, p≡p foundation's council president, who now cannot be present.)

JRuby has been compatible with various Ruby versions during its lifespan, ranging from the 1.6 series through today's 2.4. JRuby has supported Rails in some capacity since the 1.0 days. And at the same time, we've continued to improve performance. In this talk we'll explore JRuby's level of compatibility today and discuss the challenges of keeping up with an actively-developed language and ecosystem.

Full backups of large storage devices are expensive, slow, and waste a lot of space. Incremental and differential backups are an oft-requested feature in virtualization stacks to help eliminate the redundant copying of backup data.

This presentation will cover recent developments in related delta-backup technologies, covering incremental and differential backups, image fleecing, dirty bitmap management, and different paradigms of consuming this data to produce reliable backups both through QEMU as an agent or via an external backup appliance.

Style

This talk will cover the incremental backup functionality in QEMU and developments since its first introduction in 2015.

The talk is intended to be a fairly light-weight, quick trip through the feature; explaining the mechanics behind both the implementation and the API. I do not intend to cover in incredible detail the algorithmic minutiae of incremental backup techniques, but 'dirty bitmaps' as a fundamental technology enabling the technique will feature quite heavily. A theme of the talk will be how these features were implemented using targeted modifications to existing stable API to unlock rich functionality while maintaining backwards compatibility -- and the difficulties faced while doing so in a diverse open source environment. Current/Future developments are intended to be a highlight of the talk.

Audience

First and foremost, students who are interested in how large-scale projects tackle problems and would like some insight to how components in "the cloud" actually manage data on a technical level would find this talk interesting. At the very least, hopefully they find it entertaining.

Secondly, any developers or hobbyists who rely on virtualization in their workflow, but may not be heavily invested or well-versed in QEMU/KVM/libvirt et al specifically could benefit from an expanded knowledge of how this FOSS virtualization stack manages data. These users may be keen to gain insight into newer, more flexible storage and backup options.

Third, Upper-layer stack developers or users who script against upper-layer virtualization stack components may be interested to hear what we're cooking up -- this includes libvirt, virsh, openstack, oVirt or any projects that count these projects as dependencies.

And lastly, anyone who has a keen appreciation for bad puns on slide captions might enjoy stopping by.

Takeaways

Attendees can expect to leave with a basic outline of the storage management solutions as they exist in FOSS virtualization today, and how we'd like to improve on them. With a copy of the slides and footnotes, attendees will be well equipped to author power-user scripts that take advantage of some advanced functionality in QEMU-kvm today that may help them eke out more mileage from their existing FOSS virtualization stack. The talk will cover general design, usage, current caveats and expected next steps for related backup features; this will hopefully provide generally relevant information for anyone interested in or contributing to the field in general.

When Free and Open Source Software (FOSS) are becoming more broadly deployed (sometimes as part of proprietary systems) amongst organisations who have limited pre-understanding of the philosophy underlying FOSS there are a number of challenges which need to be successfully addressed. Such challenges include licensing obligations for FOSS and a number of associated legal issues, such as patents, trademarks, procurement law, and various conditions (e.g. FRAND-terms) for use of standards. Many companies and public sector organisations struggle with these challenges and there are sometimes tensions and legal disputes between different interests, which may involve organisations and individuals contributing to specific open source projects.

This panel seeks to address the following overarching question: Which are the contemporary legal and policy challenges needed to be better understood through systematic research studies, and what relevant studies should be designed and conducted in order to produce relevant research results as well as practical outcomes in order to shed light on these challenges?

The (45 minutes) panel will start with short position statements by the panellists and a dialogue between them. Significant time will be allocated to an open discussion on the issues with the audience, and those attending are invited to raise their own concerns and share their own experiences.

When Free and Open Source Software (FOSS) are becoming more broadly deployed (sometimes as part of proprietary systems) amongst organisations who have limited pre-understanding of the philosophy underlying FOSS there are a number of challenges which need to be successfully addressed. Such challenges include licensing obligations for FOSS and a number of associated legal issues, such as patents, trademarks, procurement law, and various conditions (e.g. FRAND-terms) for use of standards. Many companies and public sector organisations struggle with these challenges and there are sometimes tensions and legal disputes between different interests, which may involve organisations and individuals contributing to specific open source projects.

This panel seeks to address the following overarching question: Which are the contemporary legal and policy challenges needed to be better understood through systematic research studies, and what relevant studies should be designed and conducted in order to produce relevant research results as well as practical outcomes in order to shed light on these challenges?

The (45 minutes) panel will start with short position statements by the panellists and a dialogue between them. Significant time will be allocated to an open discussion on the issues with the audience, and those attending are invited to raise their own concerns and share their own experiences.

About the panellists:

Björn Lundell (Ph.D.) is a senior researcher at the University of Skövde, Sweden.

Associate Professor Björn Lundell (Ph.D.) is a senior researcher at the University of Skövde, Sweden. He leads the Software Systems Research Group, has conducted research related to free and open source software for a number of years and participated in a number of research projects in different leading roles. His research is reported in over 100 publications in a variety of international journals and conferences. He was the program co-chair for the 8th and 12th International Conference on Open Source Systems (OSS 2012 and OSS 2016) and is the project leader for the collaborative research project LIM-IT (www.his.se/lim-it), which address fundamental FOSS challenges in collaboration with several industrial partners.

Dr. Matthias Stürmer is head of the Research Center for Digital Sustainability at the Institute of Information Systems at University of Bern since 2013. As a post-doc he is researching, teaching, and consulting on digital sustainability, open source software, open data, open government and ICT procurement. Previously he worked as IT advisory manager at EY (Ernst & Young) and as project leader at Liip AG, a Swiss software company creating agile Internet solutions based on open source technologies. In 2009 Matthias finished his doctoral dissertation at the Chair of Strategic Management and Innovation at ETH Zürich focussing on open source communities and firm involvement. He studied business administration and computer science at University of Bern until 2005 (lic.rer.pol) and wrote his master thesis on Open Source Community Building. Currently Matthias Stürmer is president of tcbe.ch ICT Cluster Bern, member of the board of the open source association CH Open, co-founder and member of the board of Opendata.ch, and secretary of the Swiss Parliamentarian Group for Digital Sustainability. Since 2011 he is member of the city parliament of Bern having initiated the increased use of and contribution to open source software in public administration and schools.

Andrew Katz is a UK-based lawyer specialising in FOSS and open content.

Prior to becoming a lawyer, Andrew Katz was a developer and has released software under the GPL. He advises individuals, corporations, foundations and public sector organisations on FOSS law issues, and is a visiting researcher at the University of Skövde, Sweden, and visiting lecturer at Queen Mary, University of London. He is a founder editor of the Free and Open Source Software Law Review.

Pamela Chestek is the principal of Chestek Legal, which counsels creative communities on branding, marketing, and protecting and sharing content.

The LibreOffice build system provides integration with a set of IDEs including Kdevelop, Eclipse, Vim/YouCompleteMe, QtCreator and Visual Studio. This allows developers on all platforms to use their preferred environment and still IDE features like code-completion on many of them without the need to manually maintain all of those. Gbuild, the LibreOffice build system, exports most relevant data about this to JSON files, which then can be used to create project solutions on multiple IDEs. This talk describes how we got there, past and future challenges and opportunities. It might also be of interest for other projects interested in providing something similar.

Converse.js is an XMPP-based webchat application that can be used as a standalone application or it can be customized and integrated into any website. In this talk I'll provide an introduction to Converse.js and I'll also explain the infrastructure required to integrate and host XMPP-based webchat.

What is XMPP and how do I integrate it into a website?

I'll provide a brief introduction to XMPP (as presence and chat protocol) and the two main technologies for integrating XMPP into the webbrowser (long-polling with BOSH versus websockets).

What is Converse.js?

Next follows an introduction to Converse.js, which is a webchat client that can be used standalone, or which can be integrated into any website. Then I'll talk about how Converse.js came to be, what it was originally used for, where it's been integrated and what's been done with it since.

How to integrate webchat into your website

In this section, I'll provide an outline of what's needed to create a webchat solution for your website. I'll mention XMPP servers, BOSH connection managers, XEPs (XMPP protocol extensions) that you'll likely want to enable, and more. I'll also elaborate on how you might want to enable communication between your web app's backend and an XMPP server.

Plans for the future

I'll then finish off by discussing plans for future improvements and enhancements to Converse.js

Abstract

Graph pattern matching is one of the most interesting and challenging operations in graph analytics. However, it is primarily supported by graph database systems such as Neo4j but, besides research prototypes, not generally available for distributed (not-only graph) processing frameworks like Apache Flink or Apache Spark.

In our talk, we want to give an overview of our current implementation of Cypher on Apache Flink. Cypher is the Neo4j graph query language and enables the intuitive definition of graph patterns including structural and semantic predicates. As the Neo4j graph data model is not supported out-of-the box by Apache Flink, we leverage Gradoop, a Flink-based graph analytics framework based on Apache Flink that already provides an abstraction of schema-free property graphs.

We will give a brief overview about the technologies used to implement Cypher, explain our query engine and give a demonstration of the available language features. Finally, we will discuss open challenges and missing features hopefully motivating people to contribute.

The project is a cooperation between the University of Leipzig and Neo Technology.

Intended audience and goal of the talk

Developers and analysts, trying to express graph queries on distributed graphs

Links to background information on the given talk for the hungry and impatient

• OpenCypher
• Neo4j
• Apache Flink
• Gradoop

Links to previous talks, code snippets or repositories

• GitHub
• Extended Property Graph Model
• FlinkForward 2015
• FOSDEM 2016

Software Defined Networks (SDNs) usually involve programmable switches with limited autonomy of decision, that heavily rely on the instructions of their controller to handle “exceptions” and to adapt to traffic evolution. In an attempt to bring back some of the dataplane logic from the controller to the programmable switches, the OpenState abstraction layer has been designed, to enable efficient stateful packet processing through programmable actions occurring at the switch level.

The first part of this talk in an introduction to OpenState and includes a description of the layer as well as some example use cases. Then the implementation prototypes of OpenState realized during the project will be presented. One, in particular, will get more focus: because eBPF (extended version of Berkeley Packet Filter) can be stateful and has been conceived to reach high performances for inline packet filtering and processing, we found it to be an excellent target for OpenState.

As for the background: the work around OpenState (and its extended version, Open Packet Processor) has been achieved in the context of the BEBA research project (Horizon 2020), that tackles dataplane programmability for SDNs. Started in January 2015 and closing in March 2017, this project has entered its final stage, mostly centered on functional and performance tests for the validation of the developed prototypes.

This presentation shows the workflow currently followed by RDO to ensure the quality of OpenStack packaging, and the specificities of the tools implementing this workflow.

After the OpenStack Tokyo Summit in november 2015, the RDO community transitioned to a delivery workflow inspired by OpenStack's own continuous integration infrastructure ("OpenStack Infra"). The platform relies on Software Factory (https://softwarefactory-project.io/) to set up automatically the tools from OpenStack Infra together, and a few additional tools specific to RDO to ensure the quality of their packages. In this presentation, we will introduce the main components of RDO's delivery platform, the problems they help solve, and how they can be adapted to set up your own "RPM Factory".

This talk will describe the NBD protocol: what is it, what can it do, and why is it relevant for virtualization and IaaS. We will also touch at a few features that have been specified for the protocol, but so far have not been implemented in any known implementation.

The Network Block Device (NBD) was originally written for the Linux kernel, to use and export block devices over a network (TCP) link. Its feature set was very limited, however, which limited its practical usability for many purposes. Over the years, however, the protocol has evolved, with features such as better negotiation, improved reliability through flush requests, and awareness of holes in backing files being implemented.

Recent versions of QEMU implement the client side of the protocol, while at the same time also being able to export local resources through NBD. This situation makes it possible for NBD to be used as a protocol for shared storage, backup, or mirroring of resources to other systems for live migration.

We will quickly cover the history of the protocol, describing some of the features that were added over the years; make a short comparison against similar protocols such as iSCSI and AoE and why NBD is relevant in that context; and then move on to newer features that were added to the protocol at the request of the QEMU developers.

After a quick introduction to pkgsrc (the NetBSD package collection), we will talk about how Go code is built, how Go handles dependencies and what challenges there are in putting the two together. It turns out that the buildlink framework is well applicable to dependencies of Go programs too. Bonus: How to make your Go code easy to package.

JerryScript is a lightweight JavaScript engine designed to bring the success of JavaScript to small IoT devices like lamps, thermometers, switches and sensors. This class of devices tends to use resource-constrained microcontrollers which are too small to fit a large JavaScript engine like V8 or JavaScriptCore. JerryScript is heavily optimized for low memory consumption and runs on platforms with less than 64KB of RAM and less than 200KB of flash memory. Despite the low footprint, JerryScript is a full-featured JavaScript engine implementing the entire ECMAScript 5.1 standard. It is actively used in production and already runs on more than one million smartwatches! JerryScript is an open source project and has been released under the Apache License 2.0. The talk will include a demo showing JavaScript code executing on top of JerryScript on a resource-constrained microcontroller.

The Serial Peripheral Interconnect (SPI) bus is a ubiquitous de facto standard found in many embedded systems produced today. The Linux kernel has long supported this bus via a comprehensive framework which supports both SPI master and slave devices. The session will explore the abstractions that the framework provides to expose this hardware to both kernel and userspace clients. The talk will cover which classes of hardware supported and use cases outside the scope of the subsystem today. In addition, we will discuss subtle features of the SPI subsystem that may be used to satisfy hardware and performance requirements in an embedded Linux system.

Thousands of contributors help building the curl software which runs on several billions of devices and are affecting every human in the connected world daily. How this came to happen, who contributes and how Daniel at the wheel keeps it all together.

This is a description of a small project with a major reach. curl and libcurl can probably be considered corner stones in a world of client-side Internet transfers and in particular HTTP, running on every imaginable operating system and CPU architecture in use today. Started in the late 90s, the software now runs in billions of devices and is quite likely one of the most widely used software components - any category. Daniel takes us through how it started, how it works and why it never gets done.

This talk will present the mechanisms of Bazel, Google's own build tool.

Bazel is Google's own build tool, open-sourced in February 2015.

Bazel has built-in support for building both client and server software, including client applications for both Android and iOS platforms. It also provides an extensible framework that you can use to develop your own build rules.

This talk will present the mechanisms that enable Bazel to deal with the scale of software made at Google while guaranteeing reproducibility of builds. It will also cover the challenges the Bazel team faced to open-source such a large tool and the future of the Bazel project.

Passbolt is a web based password manager designed for collaboration build on top of OpenPGP. In this presentation we will give a quick overview of the product functionalities, a high level introduction to the code architecture as well as our methodology and tooling for developing and testing the product.

Passbolt is an open source password manager built for collaboration. It allows your team to securely share and store credentials. For instance, the wifi password of your office, or the administrator password of a router or your organisation social media account password.

Passbolt is different from the other password managers because it is: - free & open source - designed for teams and not individuals - based on OpenPGP - easy to use for both novice and IT professionals alike - extensible thanks to its restful API - respectful of privacy

After a quick product demo, this talk will focus on the inner workings of passbolt, its high level architecture as well as our methodology and tooling used for the development and testing the product.

Most SDR hardware nowadays includes an FPGA of sorts, but how to make use of them in an SDR application is often unclear for newcomers to the SDR ecosystem. Even more daunting can be to take first steps into FPGA-land and start writing code for your reprogrammable chips. We will talk about how an FPGA is actually useful for SDRs on an very basic level, and provide a very basic introduction into how to use the RFNoC framework to start using (and maybe learning) FPGAs.

The following topics will be covered: - How are FPGAs already available in modern SDR hardware? - Which tasks are FPGAs well suited to tackle? - When do we move tasks to an FPGA, and when do we not? - How can we enter the realm of FPGA development using the RFNoC framework?

Garbage Collection (GC) liberates the programmer from having to call malloc and free. More importantly GC saves the programmer from having to debug their mistakes when using malloc and free. Unfortunately the details of how GC works are often a black box. This talk will start with a tour of all of the GC algorithms currently available in OpenJDK. We'll discuss how they work, their strengths and weaknesses, and which class of applications they were developed for. We'll work our way through serial gc, parallel gc, concurrent mark and sweep, and g1. We'll make the case for why we need all of them and just one more GC algorithm, Shenandoah.

Shenandoah is a parallel and concurrent GC algorithm designed for applications with 100gb+ heaps and tight pause time constraints. It's the first GC algorithm targeting OpenJDK which compacts the live objects while the Java threads are running. We'll describe the algorithm itself, the implementation details, and the optimizations needed to achieve good performance. We'll present performance numbers and give a demo that visualizes Shenandoah.

C has been the de facto systems programming language for decades, so huge amounts of useful programs and libraries are written in that language. New Rust code can make use of that legacy of work via FFI, but to get the full advantages of Rust, legacy software needs to be re-written in Rust. Corrode is a tool to semi-automate these rewrites by producing Rust source that behaves exactly like the original C, enabling developers to focus on the interesting parts of improving code quality. I'll talk about what Corrode does and does not do; present case studies of Corrode-assisted translations; and discuss rationale for decisions such as writing Corrode in Haskell or documenting in "literate programming" style.

rinohtype is a batch document processor that renders structured documents to PDF based on a document template and style sheet. rinohtype is written in Python 3 and supports CommonMark (Markdown) and reStructuredText input. A Sphinx builder is also provided that can produce PDFs from Sphinx projects, obviating the need for LaTeX.

The talk will present the design of rinohtype and illustrate how the style of documents can be easily customized using document templates and style sheets.

Experiences of supporting HPC/HTC workloads on private cloud resources, with ideas for how to do this better and description of trends for non-traditional HPC resource provision.

I will discuss my work as part of the Operations Team for the eMedLab private cloud, https://www.emedlab.ac.uk, which is a large-scale (6000-core, 5PB) biomedical research cloud using HPC hardware, aiming to support HPC workloads. This includes an account of the technical challenges of marrying traditional HPC components such as parallel filesystems with the rather different expectations of the OpenStack cloud management framework. Other challenges faced include educating users about the basics of virtual environments, providing access to restricted-license large-scale (800TB) datasets in a multi-tenant environment, and achieving good performance inside virtual HPC clusters.

Looking to the future, container orchestration engines such as Kubernetes provide a very promising approach, as the containerisation of scientific applications gains momentum, and I will describe existing and future work in this area.

If you need to manage more then a reasonably sized infrastructure in today's day and age you will want to automate things as much as possible. In order to do that properly, you'll need to use tools that help you manage your infrastructure. This poses a problem: before you can manage your infrastructure, you now need to manage the infrastructure you will use to manage your infrastructure. The interesting bit is that if you use industry best practices, a lot of that management infra will look the same or similar across organisations. So why do we need to reinvent the weel over and over?

This talk will present OpsTheater, a stack of tools used to manage an infrastructure made up of current industry best practices (Puppet, GitLab, Icinga, ELK stack). OpsTheater is a fully open source project that was started in late 2015 and is growing to be a great set of tools that takes away the work we do over and over: managing the infrastructure to manage our infrastructure. We will look at the problems OpsTheater solves, the state of the project and what you can do with it today. If you want to help, we'll show where you an go and what you can do. If time permits, a demo will be added showing some of the things we can do with OpsTheater.

As proxies (and database routers) go, the first one I ever used was the now deprecated MySQL Proxy. Since then, I've managed to use MariaDB MaxScale quite a bit (including its fork AirBnB MaxScale), played around with ProxySQL in recent time, and also started taking a look at MySQL Router. In this quick 20-minute overview, we'll discuss why these three exist, a feature comparison, and reasons when to use the right tool for the job.

How to scale out an engineering workload in HPC with Apache Bigtop.

The Speaker will present how to setup up Big Data scenarios using the tools contained within the Apache Bigtop project. Apache Bigtop is a framework to compile, package, test and deploy Big Data components supporting all major Linux distros. The speaker will demonstrate how to install and configure a single node or deploy to a cluster using the supplied package repositories and puppet manifests. As an example usecase he will demonstrate how to run Apache Spark to scale out a python engineering workload from single node to a HPC environment.

The Internet has shifted to the current 128-bit IP protocol but some networks are still lagging behind. This talk is about issues with the dual stack scenario, changes to protocols needed and real world experiences of implementations.

The Internet has shifted to the current 128-bit IP protocol but some networks are still lagging behind. This talk is about issues with the dual stack scenario, changes to protocols needed and real world experiences of implementations.

SIP was written for both IPv4 and IPv6, but not for both at the same time. The talk is about experiences from SIPit tests, code and real world implementations on mobile networks - what happens with your software when being faced with both protocols? Can this affect your old IPv4-only implementation as well? What is the best option when my software crashes and generates core dumps?

This talk focusses on how QtPass went from a 2 evening necessity project to get management in on using a group password manager, to a full fledged project with over 40 contributors that is available on all linux distributions and OSs.

Working at a full service internet bureau I was shocked to see their way of storing credentials. The most shocking thing was that this seemed to be defacto industry standard behaviour.

A solution for the developers was soon found in pass, the standard UNIX password manager.

Unfortunately management in unable (or rather unwilling) to use CLI tools. So in two evenings I wrote a quick graphical read-only password viewer that used pass to allow management to view passwords. As an added bonus, all internal mails between developers and management were now instantly encrypted aswel.

I put it on github, under a group label, did a little hackathon to have people help me translate it to some languages and thought that was it.

But this was only the start of my adventures into opensource project management.

Genode recently gained the ability to execute the same binary executables on kernels as different as seL4, NOVA, or Linux. Such kernel-independent executables are created via a regular tool chain and executed natively on the machine. The talk explains how it works, presents the challenges that had to be overcome, and gives an outlook of how Genode will leverage this ability in the future. The talk will be presented on a laptop running a Genode system and will be accompanied with live demonstrations.

Apache Spark is one of the most popular new "big data" technologies, and now has a sci-kit-learn inspired pipeline API. This talk looks at how the pipeline API works as well as how to add your own custom algorithms to Apache Spark.

Apache Spark is one of the most popular new "big data" technologies, and now has a sci-kit-learn inspired pipeline API. This talk looks at how the pipeline API works as well as how to add your own custom algorithms to Apache Spark. The talk will be focused in Scala, but the same techniques can be used in Java or with other JVM languages. Sadly extending the pipeline API can not currently be done in non-JVM languages, but the information on how to use the pipeline API will be useful to Python and R users as well.

Making Valgrind faster is a never ending challenge. In this talk, we will describe 2 optimisations in Valgrind.

A first optimisation is a speedup of Helgrind (a race detection tool). A very simple observation has led to an optimisation in the way helgrind captures stack traces for its 'full recording' of where a piece of memory was modified. This optimisation gives a typical speed up of 25%. We will describe the issues encountered during the implementation and discuss the reasons why this optimisation is not (yet?) committed in the Valgrind sources.

The second optimisation is the implementation of the execution tree concept : this generalises the way Massif (a heap profiler) records the memory usage of a program. We will show how a (maybe counter-intuitive) representation of a tree using a hash table of flat stack traces has doubled the speed of Massif for some workloads.

This talk is aimed at Valgrind developers and any application developer interested in data structures and algorithm optimisations.

Yocto/OpenEmbedded is a very famous build system for embedded Linux and according to the last "IoT developper survey", it's the the most used OS for IoT devices. During the conference, we will describe some advanced Yocto/OE features in order to build a simple sensor based on Raspberry Pi zero.

Building a sensor with Yocto could be quite simple. During the conference we will explain hown to integrate an I²C sensor with Raspberry Pi zero.

• setting up Wi-Fi connection
• writing recipe for I²C temperature/pressure device control
• adding a Linux service to get data from sensor through I²C bus
• adding NTP client with Yocto package management (SMART)
• building a dedicated distro for the device
• adding everything to a new layer (meta-iot)

The G1 garbage collector is currently proposed to become the default garbage collector in JDK 9. Recently three new ideas for G1 were described on the hotspot-gc-dev at openjdk.java.net mailing list: - parallel full GC - throughput write barriers - rebuilding remembered sets during concurrent mark

This talk will present these three new ideas so that people who are interested in getting into G1 development know where to start, see what the existing code looks like today and highlight how one can contribute (it is not only about code!).

The presentation can be made longer if people want to dive deeper into the details (but it can also fit in a 25 minute slot).

Instead of speaking about successful parts of the projects, this talk will focus on the weakness of both OpenBSD and FreeBSD, exploring conceptual differences between them and also exploring directions where motivated contributors can start working on to improve the projects. While being general purpose operating systems we will see that one size doesn't fit all and how one or the other may be a better solution to a particular problem. Trolls are to be left at the door.

Mining frequent itemsets is an established approach to data mining and supported by productive data mining solutions. For example, one can get insights about buyers’ behavior by analyzing frequent co-occurrences of products in shopping baskets. In contrast, frequent subgraph mining (FSM), the graphy variant of frequent itemset mining, not only evaluates entity co-occurrence but also relationships among entities, i.e., structural patterns. However, existing implementations are all research prototypes which are tailored to textbook problems.

In our talk, we want to give an introduction to the FSM problem on distributed collections of graphs and our implementation in Gradoop, an open source system for scalable graph analytics based on Apache Flink. In contrast to other iterative graph algorithms like page rank, in FSM the search space is dropped but intermediate results of iterations are the desired result. Here, the major technical challenge is the respective usage of Flinks’ distributed iterations.

We will explain different implementation approaches, discuss implementation details which influence scalability and show benchmark results.

Intended audience and goal of the talk: Developers and analysts, interested in relationship-centric data mining techniques

Desired length of your time slot: 30min

Links to background information on the given talk for the hungry and impatient: http://www.gradoop.com http://flink.apache.org/

Links to your previous talks, code snippets or repositories: http://dbs.uni-leipzig.de/file/GraphMiningforComplexDataAnalytics.pdf GitHub: http://www.gradoop.com/ Graph Data Model: http://dbs.uni-leipzig.de/file/EPGM.pdf Fosdem 2016: https://fosdem.org/2016/schedule/event/graphprocessinggradoopflink_analytics

Heard about OpenDaylight and SDN? Ready to get your feet wet and start kicking the tires with an OpenDaylight installation? This session provides a brief intro to Software Defined Networking (SDN) in general, and more specifically to OpenDaylight, an open source platform for programmable SDN. After providing a high level overview of the architecture, the session goes on to show you how to deploy OpenDaylight and interact with it through the CLI and graphical tools. You will learn how to configure various options and enable/disable various features, and how to check the logs to verify things are working as planned and trouble shoot things when they are not. Lastly we show you how to interact with OpenDaylight through its northbound APIs for network aware applications and southbound plugins to physical and virtual network elements.

Mozilla's SpiderMonkey library can be used to embed JavaScript in any C++ projects. It is quite easy to expose some simple bindings and get a "hello world" application running in no-time.

However, after this first hello world, you'll quickly notice that you'll need other features such as timer, networking, file access, threading or even graphics and audio. At this point things get much more complicated, and maintaning the bindings can quickly become overwhelming.

Our team has been creating such bindings for SpiderMonkey since 2007 in several projects and this talk will present best practices, tips and caveats that we have learned over the years. We will also see how to make embedders life easier by using nidium library that bundles many basic bindings, in the hope that more developers can use the power of SpiderMonkey in a convienient way.

Following the progress of the Modularity initiative and Factory 2.0 developments in Fedora, it's about time we define what the next, modular operating system should look like, focusing on the developer’s point of view.

This first half of this talk will present the main concepts of Modularity, explaining in detail what modules are, how they get built, composed, distributed and kept updated once deployed on the target system.

The second half of the talk will explore the idea of the so-called Generational Core, often also referred to as Base Runtime — a modular platform base on top of which application modules can both be built and executed.

Both these topics cover ongoing efforts and we don’t yet have definitive answers to all the questions. We’ll talk about what we learned in the past year, what problems we’re trying to solve and our plans for the future.

DAMP: Docker is the component that makes the whole environment portable (only bash and Docker needed to set it up) Ansible is an agentless config management system that makes the whole setup automated and painless ProxySQL is a rising star on MySQL's horizon giving full control to DBAs over queries before they hit the DBs. MHA is an proven MySQL HA solution that's easily customizable

My aim with this demo/repo is to show people how easy to set up a test environment with to test a really good MySQL HA/Proxy solution.

Attendees will gain insight into how to leverage Ansible plays to automate many tasks for managing a highly available MySQL environment with the ability of read/write split, load balancing, on-the-fly query rewrite(ProxySQL). We're going to demonstrate scenarios like: - Building HA environment in 3 minutes - ProxySQL auto dynamic config generation with Ansible - failover without losing a single SELECT

A fully working Ansible playbook will be available for the attendees running in Docker

BigBench is the brand new standard for benchmarking and testing Big Data systems. This talk first introduces BigBench and how problems can it solve. Then, presents both Hive and Spark benchmark results with with their respective 1 and 2 versions under different configurations. Results are further classified by use cases, showing where each platform shines (or doesn't), and why, based on performance metrics and log-file analysis.

BigBench is the brand new standard (TPCx-BB) for benchmarking and testing Big Data systems. The BigBench specification describes several application use cases combining the need for SQL queries, Map/Reduce, user code (UDF), Machine Learning, and even streaming. From the available implementation, we can test the different framework combinations such as Hadoop+Hive+Tez (with Mahout) and Spark (SparkSQL+SparkML) in their different versions and configurations, helping us to spot problems and possible optimizations of our data stacks.

This talk first introduces BigBench and how problems can it solve. Then, presents both Hive and Spark benchmark results with with their respective 1 and 2 versions under different configurations including: Tez, LLAP, and file formats. Experiments are run on Cloud and On-Prem clusters of different numbers of nodes and testing data scales, taking into account interactive and batch usage. Results are further classified by use cases, showing where each platform shines (or doesn't), and why, based on performance metrics and log-file analysis. The talk concludes with the main findings, the scalability and limits of each framework.

During the last few years there has been significant debate over approaches to GPL enforcement in technical and legal communities. This talk presents a new and unique vendor perspective on free software license enforcement that emphasizes the goal of fostering greater collaboration and participation in community development and highlights the importance of transparency regarding funding relationships and conflicts of interest arising out of enforcement activities.

During the last few years there has been significant debate over approaches to GPL enforcement in developer and legal communities. This talk presents a unique vendor perspective on free software license enforcement that has been shaped by deep organizational involvement in free software development, longstanding cultural ties to GPL-using communities, and a strong corporate emphasis on ethical conduct.

Where compliance efforts adhere strictly to certain principles, they can provide a legitimate mechanism for ensuring that everyone plays by the rules established by the community through the license. But the ultimate objective of enforcement should be to foster greater collaboration and participation in community development.

The Principles of Community-Oriented GPL Enforcement published in 2015 by the Software Freedom Conservancy and Free Software Foundation represent a good first step in articulating an appropriately principled basis for copyleft enforcement. However, there are some gaps in the Principles that should be addressed by communities supportive of license enforcement. In particular, for enforcement to have community legitimacy, there needs to be an expectation of disclosure of funding relationships and exposure and resolution of the potential conflicts of interest that may arise in enforcement activity.

Ring is free software for communication developed by Savoir-faire Linux in our Montréal offices. It was conceived and developed on a peer-to-peer architecture model, relying on OpenDHT, its dedicated distributed hash table for retrieving its users on the network. Ring's Beta 2 version released on november 4th 2016 provides many new features for its users. The most interesting of them is the identity and account management mechanism, implementted on a blockchain Ethereum technology.

Since the project started and the software's first release about 2 years ago, Ring has evolved in many directions. Our new Beta 2 release features new funcionalities developed to improve the user's experience: The Multi-device function makes it possible for users to associate many devices to the same identity (many RingID's to the same identity/person), and all the devices will be synchronized. The Blockchain supports the multi-device feature for the identity and account management. It is implemented on an Ethereum technology. OpenDHT library was enhanced in order to optimize user's retrieval on the p2p network and decrease the network's operations time. Ring is now available on UWP (Universal Serial Platform thus offering support for Ring's clients on different platforms supported and maintained from Microsoft.

Finally, we are planning to release Ring's first stable version in a few months, which will introduce new elements and potentially a higer level of software reliability, users' privacy protection, utilisability and a better user experience

The Armadito antivirus project

We will present Armadito, an open source and multi-platform antivirus. Its original modular architecture allows third-party developers to add their own malware detection modules, written in C and in the future in Python or Go. Current modules are signature-based (ClamAV), rules-based (YARA) or heuristics. It provides also real-time detection on GNU/Linux and MS-Windows.

Armadito provides graphical user interfaces to notify of malware detection, launch scan, view statistics and journal. A central administration console, integrated as a GLPi plug-in, allows a system administrator to manage all the installed antivirus, view alerts, launch remote scans, deploy configuration or bases.

Project has several opened issues that are not addressed yet: high memory footprint, sandboxing for scan modules, automatic generation of signature bases from automatic malware collecting. Contributions from the free software community would be highly appreciated.

Armadito project is on github: (https://github.com/armadito)

The Armadito antivirus project

What is it?

Armadito is an open source antivirus, that runs on GNU/Linux and MS-Windows. Its modular architecture allows easy integration of new detection algorithms.

Armadito provides standard antivirus features: on-demand scan, quarantine, alerts, journal and real-time (or "on-access") protection. This protection is implemented on GNU/Linux using fanotify and on MS-Windows with its own driver.

Modular architecture

Armadito scans files using scan modules, which are plugins written in C and using a common API (load, configure, scan, unload).

Current modules are:

• ClamAV using libclamav
• YARA
• heuristic for PE and ELF binaries
• heuristic for PDF documents

A future extension is to allow writing modules in Python and Go languages.

User interfaces

Armadito provides 2 user interfaces:

• a lightweight graphical user interface, showing only notifications plus "systray" icon, developed using native toolkits
• a full interface, developed using web technologies (AngularJS), that runs in a browser and uses the antivirus REST API

Antivirus administration

The installed antivirus can be managed from a central console, that allows through a web interface to view alerts, launch remote scans, deploy new bases or configuration. This console is integrated as a GLPi plugin.

Next steps

Future developments of the project are:

• update MS-Windows code and release a MS-Windows version with installers
• make extensive testing
• improve documentation
• re-implement the heuristic module for PE/ELF binaries analysis
• provide an API to allow scan modules to be implemented in Python and GO
• improve code quality using sonarqube
• contribute to IRMA with Armadito plugin
• make Armadito antivirus be available inside virustotal.com and AVCaesar

Issues

The project has several opened issues which are not obvious to address:

• memory footprint is too high, approximately 450M when using the ClamAV module, when compared to standard antivirus which have a momory footprint in the order of 100M
• scan modules should run inside a sandbox because they parse complex formats and unpackers, and a bug in the parser or a deliberately malformed file can crash the module and therefore compromise the entire antivirus
• providing up-to-date and good "signature" bases is yet to be done; it requires a strong architecture for malware collecting and automatic signature (likely YARA rules) generation

The current team is small and contributions from the free software community would be highly appreciated.

Links

Code: github.com/armadito

Documentation: armadito-av.readthedocs.io

Talk: gitter.im/armadito/armadito-av

Ubuntu PPA: launchpad.net/~armadito

Frequency Division Multiple Access (FDMA) schemes are widely used in many existing communication systems and standards. On Software Defined Radio (SDR) platforms, separating the channels can prove more difficult though due to high requirements for the digital filters. This talk will showcase an implementation of a polyphase filterbank on a graphics processor unit (GPU) that can help overcome the heavy computational load of those filters. In the software, all the partitioned filters can run in parallel. Each of these filters produces output samples for numerous input samples simultaneously, thus providing an additional parallel approach. Furthermore, several rational oversampling factors are supported by this implementation. Operations for oversampling can as well be implemented to run in parallel, due to the massive amount of usable hardware threads in a GPU. Hence, the effects of oversampling on the throughput can be reduced. On an Nvidia GTX970 GPU, this implementation achieved a throughput of 67.43 MSamples per second, 12 times higher than the (optimized) general purpose processor (GPP) version.

Separating information using the frequency space is rather simple if one can do it with appropriate hardware. Cycle accurate operations executed in FPGA and ASIC fabric allows one to carefully create the desired waveform and then control filterbanks and oscillators. This way, the desired information can get into the air at the exact time and frequency one fancies. Unfortunately, controlling a software defined radio (SDR) in that manner can prove to be quite a challenge. Timing constraints when changing the center frequency often turn out to be the main limiting factor [1]. Instead, a pure SDR approach is often the desired way of generating multifrequency content. To cope with hard latency/timing constraints, the solution is to generate the whole spectrum at once and to position the desired information digitally into the time/frequency matrix.

But this poses quite a challenge as one usually, depending on the number of channels, has to tremendously oversample the signal to generate the aggregated bandwidth. The needed anti-imaging filter at the transmitter side and the separation/anti-aliasing filters on the receiver side can grow to obscene amounts of filter taps. Coping with this amount of computational load can be demanding, even for high-end general purpose processors (GPP). Using a polyphase filterbank (PFB) to do the synthesis/separation of the waveform can help eminently with reducing the computational load. PFBs do this by breaking down the needed filter in several polyphase partitions and doing the filtering on these partitions. A division of a filter in M polyphase partitions can already reduce the theoretical computational load by exactly a factor of M [2]. Additionally, the Fast Fourier Transform (FFT) can be used to extract or generate all channels needed at once, using just one filtering operation.Still, the challenge of separating the channels can prove to be too much for the GPP, even with the help of a PFB channelizer/synthesizer.

Using a graphics processor unit (GPU) can help immensely with offloading the critical task of separating the dedicated channels, providing some headroom for the GPP to perform the remaining task of decoding the information imprinted on the individual channels. Filtering itself is an operation that can be mapped pretty well onto many-core architectures, especially if the constraints on latency and buffer sizes are not as stringent. But the operations inside a PFB really seem to be made for over the top parallelization. The notion of performing several independent polyphase partitioned filtering operations at once is something that can be easily mapped onto common GPU architecture abstractions, as every polyphase filter partition can run simultaneously.

Most GPUs have even more computing capabilities and their resources would lie idle if one only parallelized the PFB algorithm in terms of polyphase partitions. Additionally, the computation of consecutive output samples is independent from each other. So one can further parallelize the algorithm by computing several output samples concurrently. If the need for oversampling of the signal arises, that too can be exploited to produce the additional output samples in parallel, thereby minimizing the additional computational stress caused by oversampling.

This talk will showcase, how all operations of the algorithm of the PFB channelizer/synthesizer can be mapped to a GPU using the CUDA framework. Examples of the code will be shown to highlight some of the oddities one can encounter when developing code for GPUs or many-core architectures in general. Benchmarks and results of the current implementation will be presented and discussed. As of now, on an Nvidia GTX970, the implementation reaches a throughput of 67.43 MSamples per second (45 channels, 5x oversampling, 1318 tap prototype filter), which is 12 times higher than an optimized GPP (Intel I7 6850K) version. Last but not least, future steps for releasing and maintaining the code will be laid out.

References: [1] M. Ibrahim and I. Galal, “Improved sdr frequency tuning algorithm for frequency hopping systems,” ETRI Journal, vol. 3, no. 3, Jun 2016. [Online]. Available: http://dx.doi.org/10.4218/etrij.16.0115.0565 [2] F. J. Harris, Multirate Signal Processing for Communication Systems. Upper Saddle River, NJ, USA: Prentice Hall PTR, 2004.

To get some initial basic understanding how Relax-and-Recover works you will use it yourself on two virtual machines on your laptop.

On the first virtual machine Relax-and-Recover (ReaR) will be installed and used to prepare that machine for disaster recovery.

The second virtual machine is the replacement machine that is used for disaster recovery of the first virtual machine.

Preconditions for this workshop:

To actively participate you need a sufficiently powerful laptop it that is ready-to-use prepared as follows:

• An NFS server runs on the laptop that exports a directory in "rw" mode.

• Two simple virtual machines are running on the laptop:

  • x86/x86_64 with BIOS (no UEFI)
  • hardware virtualization (no paravirtualization)
  • a single virtual 20GB harddisk (IDE disk)
  • a usual virtual CDROM drive (IDE CDROM)
  • a single usual virtual network interface card (no special driver/firmware)

• A small and simple Linux system is running on the first virtual machine that is installed in a single ext3/ext4 filesystem with GRUB/GRUB2 as bootloader.

• The Linux system running on the first virtual machine can access the NFS server that runs directly on the laptop.

• A second "empty" virtual machine without an operating system that is identical as the first one (BIOS, same 20GB harddisk, CDROM, same NIC).

• Preferably a recent ReaR version is installed on the Linux system that is running on the first virtual machine

What will be done step by step:

If not already done Relax-and-Recover (ReaR) will be installed on the Linux system that is running on the first virtual machine.

ReaR will be set up (configured) for disaster recovery.

By running "rear mkbackup" on the first virtual machine one gets on the NFS server a backup.tar.gz and a rear-hostname.iso.

The first virtual machine is shut down to simulate a disaster happened.

The second virtual machine is booted from the rear-hostname.iso via CDROM.

Now the special ReaR rescue/recovery system runs on the second virtual machine and by running "rear recover" therein one gets on the second virtual machine the system re-created as it had been before on the first virtual machine.

Unikernels are often touted as being the building blocks of next generation of cloud infrastructure. However, even the process of compiling and booting them remains daunting for the average developer let alone building out infrastructure for them to live on. In this talk we'll dive deep into the various layers of infrastructure one needs to understand in order to build out their own infrastructure for unikernels. What might seem simple at first quickly becomes difficult as one needs to cast aside preconceived notions of what an operating system and application are and how they might interact together. We'll approach everything from hypervisor orchestration to filesystems, networking and best practices for CI and testing. The attendee should be comfortable exploring unikernel cloud concepts by the end of the talk.

Unikernels are often touted as being the building blocks of next generation of cloud infrastructure. However, even the process of compiling and booting them remains daunting for the average developer let alone building out infrastructure for them to live on. In this talk we'll dive deep into the various layers of infrastructure one needs to understand in order to build out their own infrastructure for unikernels. What might seem simple at first quickly becomes difficult as one needs to cast aside preconceived notions of what an operating system and application are and how they might interact together. We'll approach everything from hypervisor orchestration to filesystems, networking and best practices for CI and testing. The attendee should be comfortable exploring unikernel cloud concepts by the end of the talk.

I have been involved with Fedora Community Operations Team where I mostly contribute on community-metrics related tasks. This talk will be about a NLP-based tool I have built for Fedora wiki to make wiki-gardening tasks easier for contributors, the methods I used for building it and how it can be scaled to any other wiki.

Fedora wiki is a community documentation space about different projects, initiatives, contributors in Fedora Project. However, due to large size of the project, the Fedora wiki has been growing in size and has become difficult to manage. As a result, wiki gardening tasks were born. These tasks generally involve not only updating current information on wiki pages but also identifying pages with redundant information to merge them, marking pages with old and outdated information accordingly etc.Most of these wiki gardening tasks are a part of one-day FADs, hackathons or sprints and suitable for new contributors looking to contribute to the project as they have a low entry-barrier. While there has been a category traditionally to mark wiki pages which need to be worked on, this task is mostly manual(needs to be done by some contributor prior to the hackathon or event) and also doesn't cover the whole wiki as it is manually difficult due to it's large size.

My tool uses Natural Language Processing-based techniques to 1.Identify pages with redundant information so that contributors can merge/delete them 2.Identify pages in a specific category/topic which need to be worked on. 3.Identify old pages which might need to be updated or categorized as out-of-date

To make the tool faster, I have used Parallel Processing techniques. In this talk, I would like to describe the tool and it's functionality, the methods I used for building it and how it can be scaled to any other wiki. I would also like to hear feedback on other wiki gardening tasks this tool could possibly be used for, and how to scale it to automatically merge pages with redundant information.

TruffleRuby runs Optcarrot 9 times faster than MRI 2.

TruffleRuby is new optimizing implementation of Ruby. Optcarrot is a NES emulator. MRI 3 targets to run Optcarrot 3 times faster than MRI 2. We will explore the techniques which allow TruffleRuby to achieve high performance in Optcarrot.

TruffleRuby runs Optcarrot 9 times faster than MRI 2.

TruffleRuby is new optimizing implementation of Ruby. Optcarrot is a NES emulator. MRI 3 targets to run Optcarrot 3 times faster than MRI 2. We will explore the techniques which allow TruffleRuby to achieve high performance in Optcarrot. We’ll discuss splitting, inlining, array strategies, Proc elimination, etc.

We now have hardware with increasing numbers of threads and functional blocks left & right. Come and hear how we plan to use that for maximum effect to make LibreOffice rock - things we have already done, things we are working on doing, and how you can get involved to encourage your PC to use more of its power to speed your LibreOffice up.

In this talk I will give a short overview of how OpenDaylight can be used to enable a range of advanced BGP use-cases - such as traffic optimisation and DDoS mitigation. The approaches presented are broadly applicable to other open-source BGP speakers but I will also show the benefit of a platform supporting multiple southbound protocols in addition to BGP.

I've been working on a new system call ABI and the required runtime support for a C variant with spacial memory safety. Along the way I've encountered lots of interesting bits and pieces required to implement a simple C "Hello, World" program. I found the process fascinating so this talk brings all that knowledge together in one place.

The first example in the classic "The C Programming Language" by Kernighan and Ritchie is in fact a remarkably complete test of the C programming language. This talk provides a guided tour a slightly more complex program where printf() is called with multiple arguments. Along the way from the initial processes' call to exec() to the final _exit(), we'll tour the program loading code in the kernel and the dynamic linker, the basics of system call implementation, the implementation of the memory allocator, and of course printf(). We'll also touch on localization and a little on threading support. Where appropriate, I'll discuss portions of the system that need changing to accommodate memory safe versions of C like the version we are developing for our CHERI CPU.

This talk will assume some knowledge of a language with C-like syntax (C, C++, Java, and PHP should all be fine).

Learning to code might be the handiest skill of the XXI. century - but finding motivation to do so seems to be the hardest part. Even when one decides to embark on this journey, their path is often hindered by the lack or quality of tools, resources they will be using, and are often turned away by the lack of success and their feeling of "coding is not for me" is often reinforced by all these negative experiences. This is where Happy Code Friends, Code Invaders and Clouduboy tries to help - introduce coding, hardware and IoT in a friendly, impulse-rich, exciting environment to anyone willing to give computers a try.

Learning to code might be the handiest skill of the XXI. century - but finding motivation to do so seems to be the hardest part. Even when one decides to embark on this journey, their path is often hindered by the lack or quality of tools, resources they will be using, and are often turned away by the lack of success and their feeling of "coding is not for me" is often reinforced by all these negative experiences. This is where Happy Code Friends, Code Invaders and Clouduboy tries to help - introduce coding, hardware and IoT in a friendly, impulse-rich, exciting environment to anyone willing to give computers a try.

Happy Code Friends is a "free one-day coding bootcamp" type of initiative to introduce anyone to web technologies and coding in general, with the intention to give them a taste of the bright side of computer programming, and start them on a way of learning coding self-sufficiently. Code Invaders is a free online webpage/tutorial teaching basic JavaScript programming concepts by building an online game. Clouduboy is a free web-based tool for creating HTML5 games with JavaScript and running/playing them on tiny microcontrollers.

Building products requires putting together many components. There are source-based distributions supporting that process. Using a pre-built, pre-tested binary distribution like Debian has its advantages.

Isar is a system for image generation using binary packages. It uses mainstream tools and workflows to build multiple products, managing common subsystems, and maintaining components from different vendors.

In this talk, Baurzhan will describe the motivation for Isar, its current state, advantages and challenges to overcome.

Ubuntu's development and stable releases have been using Continuous Integration for about four years now, using thousands of tests for gating the landing of changes. This talk shows how this works on both a technical and organizational level: test cases and their maintenance, the infrastructure to run them, the benefits and problems with it, and how this helps other distributions and upstreams.

This talk will cover the latest development and organizational news of the free and Open Source Eclipse IDE. You will learn for example what we are doing to improve Java tool performance by a factor by 1000 and why we think developing support for a new programming will be much easier with the new release.

I also cover how people can contribute to the project.

Big repositories, complex query builders, tight coupling to your ORM. Adding new behaviors and search methods can be a mess.

Don't struggle anymore! This talk shows you how to decouple you from the ORM and writing general search behaviors for all your entities with the specification pattern. Your new specifications are not tied to any specific ORM and can be reused on different levels.

Nowadays Trusted Platform Module is present in most computers, and it is making its way into embedded platforms as well. In this talk I will explain how to use the (firmware)TPM2.0 available on the Minnowboard MAX/Turbot (see also https://fb.me/MinnowBoardMax and https://fb.me/MinnowBoardTurbot) for everyday's encryption (https://fb.me/tpm2-openssl)

Even though TPMs are cryptographic processors, it is surprisingly hard to use them for common cryptographic operations like signatures and decryption.

Moreover, as opposed to its predecessor TPM1.2, TPM2.0 gets a very little support in Linux and the TGC Software Stack has no support for the most common encoding formats (e.g. PEM and DER).

Viewing the potential changes when changing the environment on a Puppet agent is challenging - much can be altered, and often the only way to know what will change is to actually run it. Using octocatalog-diff (from GitHub) and TheForeman (using a new plugin) we can now view these changes up front, in the UI, before switching the agent to the new env.

Please note that this talk was originally scheduled to be given at 11:00 The talk originally in this slot, "Next Generation Config Mgmt" by James Shubin will now take place at 11:00.

Octocatalog-diff is a commandline tool to show the differences between two puppet environments for a specific node before the node is moved to the new env. That's great, but not everyone wants to work on the commandline

In this talk we'll look at a new Foreman plugin (foreman-puppetdiff) which brings this functionality to the Foreman UI. We'll cover the basics of octocatalog-diff (installation, uses, limitations) and then show how to set up the Foreman plugin and use it in the UI.

FROSTED is an acronym that means "FRee Operating System for Tiny Embedded Devices". The goal of this project is to provide a free kernel for embedded systems, which exposes a POSIX-compliant system call API. In this talk I aim to explain why we started this project, the approach we took to separate the kernel and user-space on Cortex-M CPU's without MMU, and showcase the latest improvements on networking and supported applications.

As machine learning (ML) finds its way into more and more areas in our life, software developers from all fields are asked to navigate an increasingly complex maze of tools and algorithms to extract value out of massive datasets. In this talk we'll try to help the aspiring ML developer by describing:

• a conceptual framework that most ML algorithms fall under
• considerations about data readiness, algorithms, and software tools from an open-source perspective
• some common mistakes and misconceptions in the development and deployment of ML systems

The goal of the talk is to aid the audience to think about ML problems in an integrated manner; facilitating the process of going from problem to prototype, making an informed choice about the algorithms and software to use, and providing examples of issues that can, and do come up in production.

The talk is designed to be informative and entertaining, with little previous knowledge required.

During this session we will cover the last development in ProxySQL to support regular expressions and how we can use this strong technique in correlation with the query rules to anonymize live data quickly and transparently.

We will explain the mechanism and how to generate these rules quickly. We show live demo with all challenges we got from the Community and we finish the session by an interactive brainstorm testing queries from the audience.

When moving from a linear processing architecture to an event-oriented one, OpenSIPS becomes able to handle more advanced SIP scenarios, as well as to perform complex integrations with external applications.

The new OpenSIPS version follows a Subscribe/Notify model, which allows the SIP routing to be driven by events. These events are triggered from both inside and outside OpenSIPS, and are internally dispatched by OpenSIPS to the right process/subscriber.

During this presentation, I will show how the asynchronous architecture revamp of the upcoming OpenSIPS 2.3 facilitates a series of state-of-the-art integrations (SIP transaction pausing while push notifications are taking effect, custom suspend-resume logic while waiting for an external event, etc.).

The discussion will also include OpenSIPS scripting, and how we tweaked it to incorporate all these changes in a simple, straightforward, and efficient manner.

While a lot of languages already have comprehensive libraries to handle graph data (like networkx in python), the same cannot be said for JavaScript.

This talk discusses how we were driven to create a multipurpose graph object specification for JavaScript and what were the design issues we soon had to tackle from implementation choices to API naming.

The result of this work is the graphology specification & reference implementation which we present to open it to feedbacks & contributions.

We will first review the state of the art of graph libraries for JavaScript and discuss the issues which brought us to create a new projet from scratch.

Then we will explain why we chose to design an open specification for a standard API rather than only providing a library.

Finally we will present the reference implementation & the attached library of algorithms and justify the technical choices made, before presenting our future roadmap and related projects (a new version of the graph rendering library, sigma.js, notably).

Alexis Jacomy

Alexis is CTO of Matlo, a data discovery web app. He spent last years working on tools to help people explore data. He also develops multiple JavaScript tools with Guillaume Plique, notably sigma.js to visualize networks in web pages.

https://github.com/jacomyal

Guillaume Plique

Guillaume Plique is a developer at SciencesPo's médialab working on a variety of Open Source projects in JavaScript, Clojure & Python. He specializes in developing software for social sciences researchers and often works with graphs, natural language processing and UIs.

https://github.com/Yomguithereal

Come and hear how you can integrate LibreOffice Online into your webservice!

Wireless mobile traffic lights are often used to secure construction sites when roads are partially blocked. Some day, when a pair of them was placed close to our home, I set off to explore how they are working. In this talk, I will describe how I used a cheap RTL-SDR together with GQRX, Inspectrum, and GNU Radio to reverse engineer the modulation and frame format of different types of wireless traffic lights. With some patience, I could also make some sense out of the bits. In particular, I was able to extract the signal state and display it in a web interface, mirroring the traffic light. A closer look at the frame format and the apparent absence of any authentication might leave one with a bit of a worrying impression regarding the security of those systems.

We share our experiences with a new framework in the Linux kernel for programming reconfigurable devices, namely MPSoC-FPGAs. Our example use case integrates reconfigurable hardware accelerators into the Crypto API. We apply a new, declarative and device-tree-driven reconfiguration framework within the Linux kernel as proposed and implemented by Alan Tull. The implemented concept maps reconfigurable regions within the FPGA to device tree nodes. The insertion of a device tree overlay triggers the reconfiguration of the corresponding reconfigurable region. The reconfiguration process consists of the scheduling, descheduling and execution phase. Based on our usecase, benchmark results for the scheduling phases are shared. We present the bottlenecks revealed by our benchmark and show currently missing components of this approach. We conclude that the current implementation is already in a usable state for developing and deploying MPSoC-FPGA based heterogeneous systems.

This talk will cover how Samba uses GPLv3 to work with both proprietary and Free Software companies to maintain software with a vibrant commercial and amateur user and developer community.

Embedded system development is a complex area in which the developers need to have a deep understanding of the underlying hardware with its configurations and interfaces, and one of the solutions to reduce this complexity is to utilize an operating system. This talk will introduce F9 microkernel aimed at low resources embedded systems powered by ARM Cortex-M microprocessors, allowing to perform real-time activities while keeping the drivers and the application isolated by a secure layer.

F9 microkernel proved itself extremely small and simple to use while still maintaining the security of the system regarding the temporal constraints with a trusted computing base (TCB) as small as 3kLoC, which is important for safety, security and reliability in mission-critical embedded systems. This talk will also present the prototype at its early stages built to experiment with the idea of third-generation microkernels heavily inspired by seL4 for resource-constrained devices with fairly strong memory protection.

Apache NiFi provided a revolutionary data flow management system with a broad range of integrations with existing data production, consumption, and analysis ecosystems, all covered with robust data delivery and provenance infrastructure. Now learn about the follow-on project which expands the reach of NiFi to the edge, Apache MiNiFi. MiNiFi is a lightweight application which can be deployed on hardware orders of magnitude smaller and less powerful than the existing standard data collection platforms. With both a JVM compatible and native agent, MiNiFi allows data collection in brand new environments — sensors with tiny footprints, distributed systems with intermittent or restricted bandwidth, and even disposable or ephemeral hardware. Not only can this data be prioritized and have some initial analysis performed at the edge, it can be encrypted and secured immediately. Local governance and regulatory policies can be applied across geopolitical boundaries to conform with legal requirements. And all of this configuration can be done from central command & control using an existing NiFi with the trusted and stable UI data flow managers already love.

Video playback for embedded devices such as infotainment systems and media centers demands hardware accelerators to achieve reasonable performance. Unfortunately, vendors provide the drivers for the accelerators only as binary blobs. We demonstrate how we built a video playback system that uses hardware acceleration on i.MX6 by using solely open source software including Gstreamer, Qt QML, the etnaviv GPU driver, and the coda video decoder driver.

While hardware accelerators are necessary to provide reasonable performance for video playback on embedded devices, the drivers that are provided as binary blobs by hardware vendors cause a lot of problems. They are linked to specific versions of the Linux kernel, may contain security and performance issues, and are pretty much impossible to debug by developers trying to build a system based on these drivers.

We built an i.MX6 based embedded system that simultaneously decodes and displays four videos. Our system solely uses open source drivers to control the available hardware accelerators.

The GUI consists of a Qt application based on QML. Using Qt and QML allows us to use OpenGL for compositing the user interface. OpenGL is backed by the open source etnativ GPU driver and the Vivante GPU.

The Qt application receives the video streams from a Gstreamer pipeline (using playbin). The Gstreamer pipeline contains a v4l2 decoder element, which uses the coda v4l2 driver for the CODA 960 video encoder and decoder IP core (VPU in the Freescale/NXP Reference Manual), and a sink element to make the frames available to the Qt application.

The entire pipeline including the Gstreamer to Qt handover uses dma_bufs to avoid copies in software.

This example shows how to use open source drivers to ease the development of video and graphics applications on embedded systems.

IoT changed deeply the value chain. End users of consumer devices aim to have an instant gratification which is based on data/metrics produced by the object. At the end, IoT makers have to execute an epic split: Build the actual device (mechanical and electronics), Be over the top in firmware development in order to be secured Design services based on the object data. Surrounding all that is a hard job for a product team. In such a context Open Source Software constitutes basic building blocks of IoT devices. Data produced by smart devices are often time series, storing them is not the challenge, many good open source solutions exists (OpenTSDB, Influx..) but developing algorithms based on your data is difficult. It can become a nightmare if you have to think about scalability. Warp10 is a 3 years old open source platform designed for collect, store and manipulate sensor data with WarpScript, a language dedicated to time series analysis. WarpScript works natively on times series stored into Warp 10 (based on either levelDB or HBase) but can be connected to any data source. When you manipulate sensor data, you must deal with privacy. Security and privacy have also been addressed by Warp 10 since its very inception, this includes fine grain access control mechanisms, encryption capabilities and throttling management. Warp10 plateform can be integrated into an open ecosystem likes Storm, Flink, or also Apache Pig with one cornerstone, the capatibility of manipulate time series with WarpScript.

The Warp 10 Platform is designed to collect, store and manipulate sensor data. Sensor data are ingested as sequences of measurements (also called time series). The Warp 10 Platform offers the possibility for each measurement to also have spatial metadata specifying the geographic coordinates and/or the elevation of the sensor at the time of the reading. Those augmented measurements form what we call Geo Time Series.

The first differentiating factor of Warp 10 is that both space (location) and time are considered first class citizens. Working with Geo Time Series allows you to have geo-located readings without having to use four separate series and having to keep track of the reading context.

Complex searches like “find all the sensors active during last Monday in the perimeter delimited by this geo-fencing polygon” can be done without involving expensive joins between separate time series for the same source.

We created WarpScript, an extensible stack oriented programming language which offers more than 700 functions and several high level frameworks to ease and speed your data analysis. Simply create scripts containing your data analysis code and submit them to the platform, they will execute close to where the data resides and you will get the result of that analysis as a JSON object that you can integrate into your application.

The WarpScript approach is another differentiating factor of Warp 10. Traditional time series platforms offer few manipulation options, usually only providing a SQL like query language which cannot express complex analysis, or providing a reduced set of aggregation functions. These approaches force you to produce more code on the client side thus increasing your development time and leading to massive transfers of unprocessed data from the platform to your applications. Our approach lets you focus on your business use cases, simplifying IoT and sensor data applications by taking care of a larger chunk of the data analysis in a very efficient way.

Safe Mode was developed to investigate and fix problems with the user configuration in LibreOffice.

This talk will present several use cases where LibreOffice's Safe Mode helps users and admins to fix problems with their LibreOffice.

VEX is the JIT at the core of Valgrind. It unpicks blocks of machine code, hands them off to the tool for instrumentation, recompiles the result, and links the instrumented version into the running image. By using a target independent intermediate representation, it insulates tools from the complexity of the underlying instruction sets.

Back in 2003, when the framework was designed, I never dreamt that it would end up supporting X86, ARM, POWER, MIPS, S390 and TILEGX in both 32- and 64-bit variants. From that perspective VEX has been amazingly successful. But the framework is now showing its age. Recent instruction set features (transactional memory, LoadLinked/StoreConditional, wide vectors) have proven difficult to implement. It supports precise memory exceptions only poorly. And perhaps worst, its simplistic compilation pipeline causes it to generate code that is uncompetitive compared to other frameworks, particularly DynamoRIO and PIN.

In this talk I'll outline VEX's structure, then talk about these problems and what can be done about them. And I'd be particularly interested to hear opinions on how much effort, and for which problem areas, should be invested in upgrading it.

For the audience, some background in compiler internals and assembly code programming would be helpful, but is not essential.

Lago is an ad-hoc virtual framework which helps you build virtualized environments on your server or laptop for various use cases. It creates and orchestrates virtual machines that can be used to run test suites and allow a developer to quickly test his code change on non-trivial flows such as live migration even before starting the CI process. In this session, we will walk through the usage of Lago in the oVirt project and how it can be extended to assist virtualization developers.

Virtualization software became a vital part of the IT infrastructure of most companies nowadays. Making sure that the software works as expected in "real world" tasks is hard, mainly because virtualization environments are usually hard to reproduce automatically. Lago is an ad-hoc virtual framework which helps you build virtualized datacenter on your server or laptop to run test suites. Being a framework, it can be extended to implement any required workflows needed by the tested software.

We will discuss how Lago works with KVM and Libvirt to create a test environment, how it can be extended to help with automated system tests of virtualization products and how it is currently used by oVirt project to run automated system tests and help developers testing their patches during development phase. We will also review and compare Lago with tools like Vagrant, when applied to the virtualization development workflow.

NFV and virtualized high performance applications, such as video processing, require a “fast data stack” solution that provides both carrier grade forwarding performance, scalability and open extensibility, along with functionality for realizing application policies and controlling a complex network topology. This session discusses how different components in OpenStack and OpenDaylight are being evolved to integrate with the new open source Virtual Packet Processor (VPP) forwarder provided by the FD.io Linux Foundation project to build such a solution stack. The FastDataStacks is run as an OPNFV project where leverages OPNFV’s continuous integration, deployment and test pipeline as well as the automated component install and test infrastructure.

While small updates normally don't disturb the services running on your system, bigger or intrusive updates can break your running services or Desktop. There are different ways of doing transactional updates like new package formats or different partitions. This talk will show how to use the features of btrfs for this with traditional package managers.

Applying small updates is normally no problem in a running system. But what about if there is a new major release of your favorite Desktop? Or a major version update of your used Linux distribution? Today’s concepts are most of the time to apply the patches in the running system and risk that a running service or Desktop breaks, or apply them all by booting an installation media and wait for quite some time until you can access your machine again. A solution for this are transactional updates.

Transactional updates are atomic, means either they applied successful, or if an error occurred, you have the same state as before. And if an update does not work, there is an easy way to go back to the last working state.

There are different solutions for this, some require new package formats, other require a second partition and you can switch during the next reboot to the other partition. I want to present a third solution: using a standard package manager and leverage btrfs for this. With snapshots and rollback on btrfs, there is already everything available what you need. This talk will give a short introduction into snapshots and rollback with btrfs and show how to combine and use this technologies to your advantage.

Ruby's Strings aggregate a collection of bytes and an encoding, allowing for IO to avoid transcoding, regular expressions to execute against raw bytes, and 7-bit strings to be compactly represented. Only the last item has been adopted by Java. To make matters worse, most Java APIs depend on Java's string representation, making them incompatible with alternative languages like Ruby. We'll explore the advantages of Ruby's string compared to Java's and discuss options for improving Java's string support in the future.

A deep introduction to a-frame, the Web VR framework from Mozilla. After this talk you will be able to build amazing vitual reality experiences using the same web technologies you already are familiar with!

FreeBSD has supported disk encryption with GBDE and GELI since 2002 and 2005 respectively. However, booting the system required storing the loader and kernel unencrypted so that the requisite GEOM module could be loaded to handle decryption. This became a significantly larger stumbling block with the introduction of ZFS, as having multiple separate partitions detracts from the advantages of ZFS, and also causes headaches when upgrading the operating system. With the growing popularity of ZFS Boot Environments, a solution was needed that allowed the kernel and loader to remain part of the primary file system, even if it was encrypted. This paper provides an overview of the design of the GELI enabled BIOS boot code and loader, as well as the numerous challenges encountered during their development.

A walk through the tale of woe that was implementing support for GELI in the FreeBSD bootcode and loader. Hear the story of a very junior developer persisting through countless complications and roadblocks to finally arrive at working code. Learn just how complicated it is to boot a computer, and how much worse it can get. In the end, we are left with working ZFS Boot Environments, even with fully encrypted pools.

Window functions are an important tool for analytical queries. Window functions act as regular functions but have access to more than one row during computation. This makes them highly useful for optimising queries involving self-joins, as well as queries that need to extract data from multiple related rows from the same table. The performance speedups obtained are sometimes 100 fold. This talk will explain how that is possible, as well as use cases for window functions.

On top of that, window functions pair well with another feature that MariaDB 10.2 has introduced - Common Table Expressions. This feature was contributed by a community member and helps make queries more maintainable and sometimes faster. This feature will be covered, mostly through the use of window functions, but also introduce new use cases.

The agenda for the talk is:

• What are CTEs
• What are window functions
• Solving problems with regular SQL and window functions
• Smoothing data
• Top-N Queries
• Difference between consecutive rows

The Raspberry PI 3 board is very popular, but mainly known as a Linux platform. But it could also be used to do bare metal development: writing low-level code without any OS. There are almost no tutorials on the internet addressing the main new feature of the RPI-3 board: 4x 64 bit cores (previous generations were 32 bit). Let's fill the gap by this lightening talk: a very short presentation of the board, how to write and build a first example and a demo of a more advanced multi-core application.

The Ruby+OMR JIT compiler adds a JIT to CRuby. However, it has challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.

The Ruby+OMR JIT compiler is one way to add JIT compilation to the CRuby interpreter. However, it has a number of challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.

Relax-and-Recover (ReaR) is a bare metal Disaster Recovery tool that can save you hours (and sometimes days) to recover a system from scratch in case of failure. However, for us developers before making a new release it is a real nightmare to test all the different Linux distributions in combination with all the known workflows that ReaR provides. It used to be a manual process of testing the recovery, but we are in progress to automate the whole process for some workflows. We will explain the internals of how we do automated testing and we will give a live demo as well.

This talk will provide an overview of the evolution of OAI architecture to cater to distributed software radio systems, in particular those characteristics of upcoming cellular networks.

This talk was moved forwards 1 hour from its original timeslot (16:45).

The evolution of radio communication networks will soon include by so-called “CloudRAN” technologies which refer to centralized radio-access infrastructure deployed in data-centers. Although exhibiting important differences in the type of processing they perform, the compute and storage architecture of these data-centers, as well as many of the software technologies, are very much modelled by those used by internet-based industries for information content management and distribution.

The future network architecture is comprised of three segments, the so-called fronthaul network, the CloudRAN data-centers and the main data-centers. The fronthaul network links the radio nodes at the extremities with the CloudRAN. These interconnection networks are typically optical links over very large distances (10-20 km) when the CloudRAN resides in the central office of an operator. Various technologies are envisaged including analog (radio-over-fiber) PON (passive optical network), TDM and WDM PON and carrier grade optical Ethernet. Other solutions will also exist for indoor networks (e.g. airports, shopping malls, large administrations, private enterprise networks, etc.) using both optical and copper-based fronthaul networks.

The software architecture of OpenAirInterface (OAI) is currently being evolved to cater to these distributed processing environments. In particular the infrastructure processing elements in OAI are being split at various places to allow them to be distributed between the central cloud processing units (RCC), the so-called radio-aggregation units (RAU) which perform centralized signal processing and switching and the network of remote-radio units (RRU). OAI now comprises two such processing splits which will be detailed along with examples of how to build simple ethernet-based RRU with low-cost commodity radio equipment (e.g. USRP B2x0, LimeSDR, etc.) and embedded PCs or ARM-based computers. In addition, The current architecture for deploying OAI in a data-center environment will be described.

A short live demonstration of networked-signal processing for 4G will be provided comprising a USRP-based RRU running on an UPBoard, an ethernet fronthaul and a mini radio-cloud-center housing the access protocol stack and a small core network.

With the recent announcement of the SAP HANA, express edition, a free to use and streamlined version of SAP HANA that can run on laptops and other resource-constrained hosts, it is now possible to use the SAP HANA Graph functionality for free in own graph projects and applications with up to 32GB main memory limit. In addition, the SAP HANA, express edition offers development utilities that can be used to develop own applications on top of SAP HANA.

In this presentation, we will provide an overview of SAP HANA Graph, a native graph processing engine, which is tightly integrated into the database kernel of SAP HANA. It allows to freely combine graph, relational, text, and geospatial processing on a single transactional data representation without the need to replicate data into specialized systems. In particular, we will use the SAP HANA, express edition running on the speaker's laptop to demonstrate the audience a walk-through of the steps to get started with SAP HANA Graph. Specifically, we will show how to execute openCypher queries in SAP HANA and also showcase GraphScript, a high-level domain-specific graph query language for imperative and complex graph query processing.

Quality of Service markings can benefit real time traffic. A survey we conducted on a mobile cellular testbed (Monroe) has revealed how differentiated services traffic is treated in practical networks, and shows many networks do not respect diffserv markings resulting unpredictable real-time performance.

This motivates a change to the network programming API for real-time traffic to provide dynamic transport selection and fallback, enabling successful use of network QoS. The API is presented in the context of the NEAT1 open source project.

OpenHMD is a community building full open source drivers for different type of VR devices such as the Oculus Rift, HTC Vive, PSVR and others. Since we found out quite a bunch of our contributors are attending this event, we would like to take this opportunity to meet up to have development and design discussions, but also to introduce new people to our project, and even help out reverse engineering new devices, or help out implementing OpenHMD in other projects!

This meeting is for everyone interested in our project and community, discuss things like VR in Open Source, multi platform development, application integration, device support and anything related in general.

For questions poke us on irc.freenode.net channel #openhmd

In this presentation, we will showcase the whole scope of PNDA, from baremetal provisioning to application deployment. Also, we will describe the current use case on NFV & IoT.

HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.

How often have you rewritten your unit tests from scratch just because the code it was testing evolved slightly? In this session we will explore some unit testing techniques from other languages to produce more robust tests in PHP. You’ll never have to send your unit test to the trashcan again.

Driver not found, incorrect driver bound, kernel oops. If you've ever experienced any of those problems while using USB then this talk is exactly for you!

We start with a gentle introduction to the USB protocol itself. Then standard Linux host side infrastructure will be discussed. How drivers are chosen? How can we modify matching rules of a particular driver? That's only a couple of questions which will be answered in this part. Final part will be an introduction to USB communication sniffing. Krzysztof will show how to monitor and analyze USB traffic.

Continuous integration brought us fast reliable and continuous testing. Continuous localisation brings the same speed and delivery to the translation of software. We'll look at how to build such a process using FOSS tools.

Continuous localisation is becoming more critical to the software delivery process. And just like continuous inegration we rely on a number of tools and automation to ensure that we deliver good translations quickly to products.

We'll be looking at continuous localisation processes using FOSS tools and mapping the parallels between modern software development and continuous localisation.

We'll cover aspects such as:

• Testing/Checking and building automated linguistic and stylistic checks
• Automated and bidirectional synchronisation between the translation tools and software repos
• Building in processes for content review both in source and target text
• Encouraging translator participation
• Delivering translations quickly and continuously

And for FOSS projects we'll show how to implement a process using FOSS tools.

Let's see how we can build small IoT devices that can help blind people in their daily life.

The Word Health Organization estimates that more than 250 million people suffer from vision impairment, 36 millions of them being entirely blind. In many cases, their impairment prevents them from living independently. To complicate things further, about 90% of them are estimated to live in low-income situations.

Project Lighthouse was started by Mozilla to try and find low-cost technological solutions that can help vision-impaired people live and function on their own. To this date, we have produced several prototypes designed to aid users in a variety of situations.

Let's look at some of them.

This will be a relatively low-tech presentation.

Config management is a perfect fit for compliance: you model desired compliant state, continually enforce it and have a full audit path of when changes occur and what lead to the drift. But what are the best practises for using config management for compliance, what are the caveats, how do you scan for issues and how can you keep the auditors happy?

If you work with or at a Telco, Financial Institution or a Government entity, you probably already know about compliance and the various acronyms and headaches it can bring.

How can we make this less of a painful process?

Well, if you think about it: compliance is a set of rules that someone has given you to enforce and prove that they're being enforced. What is configuration management? A series of rules for systems that need to be enforced. So compliance is the perfect use-case for configuration management.

We'll be discussing how you can enforce compliance in your estate with config management, what open-source tooling you to perform scans across your estate and how to save time by leveraging existing work such as http://dev-sec.io.

We'll also be talking about how to sell the benefits of config management for compliance to stakeholders and some real-life examples of how it's worked with customers in the past, and the caveats that come with it.

The Crazyflie 2.0 is a nano quadcopter, a flying open source development platform invented by Bitcraze. It features a modular design (similar to Arduino), powerful and robust hardware, polyglot and cross-platform software support and has been used in different private and academic science and research projects around the world.

This talk will focus on news from the Crazyflie universe, like new expansion boards, software improvements, interesting research projects and most importantly the new indoor positioning system based on UWB radios. It promises to make indoor navigation two orders of magnitude cheaper than commercial systems.

When designing technologies, networked systems, and measurements on the Internet, we must be aware of their implications and consequences for the society and participants. As engineers, scientists, programmers and other experts, we have moral obligations towards our peers, users of technologies we create, and the wider communities.

In this talk I want to talk both about general ethical considerations, and specific examples of moral dilemmas that come from building the RIPE Atlas system, and conducting measurements that reveal workings of Internet infrastructure and services.

RIPE Atlas is an extensive measurement network, where the vantage points (sources of measurements) are hosted by volunteers: mostly individuals at home, but also some institutions (ISPs, IXPs, academia, various other businesses). RIPE Atlas users are using someone else's Internet connection to do measurements. In order to recognise ethical considerations surrounding use of RIPE Atlas, we looked both into the historical considerations of engineers and scientists, and into practical constraints users should keep in mind, and we published some findings in this article: https://labs.ripe.net/Members/kistel/ethics-of-ripe-atlas-measurements

Many developers do not consider web standards while create their webpages/apps. This will create a bad experience for some users that not use that product with a certain OS or application. This talk will cover best practices and give examples of how some users could not do some simple booking because of the bad experience given by the website for their app. This will cover web in general, not only Firefox.

Many developers do not consider web standards while create their webpages/apps. This will create a bad experience for some users that not use that product with a certain OS or application. And nowdays there are way to many configuration available to be sure you use the right one. And a limited memory will narrow your option to have several apps installed only for certain webpages. Some simple example for a bike sharing system, a Michelin rated restaurant from Stockholm or a museum in Krakow - that worked poorly on several browsers will show the importance of compatibility. Best practices for developers will be presented. Best practices for report issues will be exemplified. Already fixed issue will present simple solutions to the audience that unblocked several users.

Hadoop has been touted as a replacement for data warehouses. In practice Hadoop has had success offloading ETL/ELT workloads, but still has gaps serving requirements for operational analytics.

Apache Bigtop now includes Greenplum Database in deployment of big data solutions. Greenplum Database is, an open source massively parallel data warehouse based on PostgreSQL, and is an excellent addition to the Hadoop ecosystem.

In this session we'll cover: * Introduction to Greenplum * Bigtop Support for Greenplum * External tables in Hadoop by Greenplum * Parallel reads and writes to Hadoop by Greenplum * Running advanced analytics on structured and unstructured data in both Hadoop and Greenplum via Apache MADlib (incubating) * Geospatial and Machine Learning in Greenplum based on HDFS data * Storing data from a data lake in Greenplum for high throughput analytical queries

How ready is musl libc? How does it actually work to build an entire distribution with musl libc? How does the community benefit from having another libc?

This talk will discuss why Alpine Linux switched to musl libc, how the migration went and how things goes now, two years after the migration.

How ready is musl libc? How does it actually work to build an entire distribution with musl libc? How does the community benefit from having another libc?

This talk will discuss why Alpine Linux switched to musl libc, how the migration went and how things goes now, two years after the migration.

Apache Spark is a cluster computing framework, similar to Apache Hadoop. There are a number of tasks where MySQL does not show great performance: for example MySQL is not massively parallel system and a single query will only utilize 1 CPU core . Spark, on the the other hand is designed to be massively parallel; in addition Spark is a clustering framework, so you can easily add more compute nodes so that Spark can utilize more resources and scale.

Apache Drill is similar project aimed to make data discovery easier. For example it allow you to join data sources in MySQL, MongoDB, flat files, other RDBMS, etc.

In this talk I will demonstrate how to use Apache Spark together with MySQL for data analysis. I will sho how Apache Spark aggregates data (wikipedia pageview statistics) and stores the resultset in MySQL. I will also show how to use Apache Spark with multiple sources and join virtual tables from MySQL, flat files and even MongoDB.

Some examples of weird behavior encountered while developing / bug fixing the LibreOffice Calc spreadsheet application.

What does it look like when we apply Open Source software licenses and practices to hardware? How do authors intend for Open Source licenses and copyleft principles to apply to hardware, across its many types of components and interconnects, and what legal frameworks can preserve that intent? Hardware raises new scenarios and questions; how might we extrapolate our principles to them? We'll propose some use cases to explore intent and ideal outcomes, and invite discussion on how to get there.

The first hardware-focused Open Source activities started around 20 years ago. But even as open hardware itself matures, the legal aspects remain relatively unexplored, and many unanswered legal questions remain. We'll examine what "licensing" means in terms of hardware, and discuss the adequacy of currently available mechanisms to express the intent of the authors and creators of open hardware. From our experience in Open Source software, we naturally attempt to find parallels in software licenses that can be applied to hardware; however, hardware designs introduce new aspects that have no equivalent in the software world.

In particular, we're especially interested in how the ideas and principles of copyleft translate. How do things like linking, derivative works, and compilation operate in terms of hardware? What "exclusive rights" belong to authors and makers in this domain, and can we offer a license to those rights the same way we can for software copyrights? What rights do builders/fabricators have? How does a license on a digital description affect the manufacture, distribution, and copying of the corresponding physical objects it describes? How do the various types of components within an open hardware design interact, and how do the licenses of those components interact over the many ways of connecting those components together? And can we apply or adapt existing Open Source software licenses for hardware, without fragmenting the ecosystem between software and hardware, especially as the lines between the two become increasingly fluid?

We'll explore each of these areas, using as a case study the creation, licensing, and distribution of a product incorporating both open software and many types of open hardware. We'll offer our thoughts on some possible properties of an ideal open hardware licensing framework, seek consensus on how our principles apply in various concrete scenarios, and invite discussion on how our legal structures can adapt to serve the needs of the developing Open Source hardware world.

This talk copes with the signal analysis toolbox gr-inspector for GNU Radio. I will talk about the development process as well as the functionality and some usage examples.

Receiving unknown signals is hard. It was already possible with GNU Radio, but much manual work and offline tweaking was necessary. Real-time signal analysis was hardly possible. During Google Summer of Code 2016, gr-inspector was developed to make these tasks more easy. The main purpose of the toolbox is to automate as much of a receiving process as possible during runtime. The components of the toolbox include a energy detection block, automated down-mixing/filtering/decimation, resampling, automated modulation classification (AMC) and OFDM parameter estimation/synchronization. Also, a GUI is able to display the analysis results. In this talk, I will give information about the background of the toolbox, what it's capable of and how to use it.

Bareos (Backup Archiving Recovery Open Sourced) is a reliable, cross-network open source software for backup, archiving and recovery of data for all well-established operating systems. Emerged from the Bacula Project in 2010, Bareos was and is actively developed as a fork and enriched with lots of new features. After a short introduction about the Bareos architecture and terminology, this session will introduce how to extend Bareos with Plugins written in Python.

Using plugins makes it possible to extend the Bareos functionality. This allows to backup and restore in an application specific and more flexible and dynamic way than normal file backup. Use cases include database backups, agentless virtual machine backups or LDAP backups. Using Python makes this a lot easier, and with its large library for connectivity and API access it is possible to address a wide range of applications.

Andrea will provide a high level perspective of the most notable milestones in the long term evolution of the Linux Virtual Memory and Virtualization subsystems. In addition, Andrea will explore recent advances in Memory Management related to the KVM Virtualization Hypervisor, such as NUMA balancing, THP, KSM and userfaultfd/postcopy live migration. Andrea will cover best practices, providing the audience with an understanding of when and how to leverage these features in their environments.

Metre is an XMPP Server, but not one that serves XMPP. Instead, it lives in the nether regions between servers - being a Man In The Middle by design and intent - filtering and securing traffic as required.

Metre supports pretty well every bell, whistle, and in fact any other musical instrument of XMPP Server to Server security. It then filters traffic, drops stanzas you don't want, eliding it totally on occasion.

It'll throw your traffic over TLS, over DANE, over SATCOM.

It'll log it all.

It'll protect your autonomous security domain.

It'll wag its little tail when it sees you in the morning, but you won't have to take it for walks.

OpenScore is a new initiative to liberate public domain music using MuseScore, the leading open-source music notation program. The aim is to unite MuseScore’s millions of users in an effort to digitise and liberate the works of Mozart, Beethoven and other famous classical composers. OpenScore extends the principles of open source to apply not only to software, but also to the content produced by the software, thereby opening up a new avenue of funding for open source software development.

The goal of OpenScore is to improve access to public domain music. The project is a collaboration between MuseScore, the leading open-source music notation program, and IMSLP, the largest online archive of public domain music.

The IMSLP archive contains scanned copies of scores by Mozart, Beethoven and other classical composers in “binary” PDF format, which allows musicians to read them, but not edit or listen to them. OpenScore will unlock the true potential of the scores by making the actual “source code” to the music available in MuseScore’s text-based format, which allows listening, editing, and easy conversion to other formats like MusicXML, MIDI and PDF, as well as all audio, video and image formats. Text-based scores offer improved accessibility over PDFs, and are easily parseable by software tools to allow searching, indexing, data mining, and analysis for research purposes.

To make this happen, OpenScore will adopt the open source model and draw upon the strength of MuseScore’s massive online community. The digital scores will be published under a Creative Commons license to allow anyone to adapt, share and improve upon the transcriptions.

OpenScore partners: MuseScore, IMSLP, RNIB, St Andrews, music21, Nicholas Rougeux

I wrote inet (the TCP/IP stack on MINIX) for two reasons: I like to come up with my own designs for everything and, most of all, I had to impress Andy Tanenbaum enough to become a Ph.D. student. Inet had to fit in with MINIX. In particular, it had to live with minimal changes to the MINIX code base. At the same time, there were quite a few areas where I felt sockets and the BSD TCP/IP implementation were wrong.

In hindsight, there is a lot that I did not know and got wrong. I this talk, I will look at how inet follows the structure of MINIX, what works, and what went wrong.

The angr binary analysis platform (http://angr.io) uses libVEX as the base of its analysis engine. In this talk, we discuss the things about VEX that make it attractive for static analysis and symbolic execution, its pitfalls, and ways that it can be improved, including the changes we have made in our fork of libVEX.

Agenda

• The goals of static analysis and symbolic execution on binary code
• Brief overview of competing analysis IRs
• Design of angr structured around libVEX
  • PyVEX, FFI wrapper of libVEX objects into python
  • simuvex, symbolic implementation of most VEX operations, ccalls, and dirty calls
• Pitfalls we've encountered
  • VEX is not truly SSA
  • libVEX is not designed for fault tolerance
  • libVEX's multiarch support is a little shoddy
  • Licensing concerns
• Our patches to libVEX
  • The only real thing stopping us from submitting our patches upstream is manpower
• The possibility of a simplified python interface for writing lifters
• angr
  • symbolic execution
  • static analyses
    • control-flow recovery
    • binary rewriting
    • type inference (sort of)
    • value-set analysis

As graph processing moves to the mainstream, a large number of specialized graph engines have emerged. However, for many enterprises, much of their important data resides in relational databases and SQL is the most common workload. So is it reasonable to suggest that relational data processing engines can be used to solve graph problems in a productive and performant manner?

The answer to this question is: “Yes!”

In this talk, we will address the use of massively parallel processing (MPP) databases for graph analytics workloads. We will share some recent findings from the Apache MADlib (incubating) project, including design of graph data structures, implementation of common graph algorithms, and performance results.

Graph analytics is becoming an important part of enterprise computing. With roots in academia going back many decades, the last 10-15 years have seen a huge surge of interest in this topic to address a wide range of modern use cases, from cybersecurity to social networks to supply distribution chains.

Enterprises have made significant investments in infrastructure, software, and training of their employees, all centered around SQL. So how can an enterprise add graph analytics to their business without the cost and complexity of moving to specialized graph processing engines? And, what are the tradeoffs?

Graph analytics is a new area of innovation in Apache MADlib, which is a SQL-based open source library for scalable in-database analytics. It provides parallel implementations of mathematical, statistical and machine learning methods for structured and unstructured data.

Many existing analytics products do not scale in a way that makes it convenient and economical to operate on large data sets. The graph methods in Apache MADlib have been designed to take advantage of the shared-nothing, scale-out parallelism offered by modern parallel database engines.

I look forward to presenting this topic at FOSDEM 17!

MicroPython is a FOSS implementation of Python 3 optimised to run on a microcontroller with MHz and tens or hundreds of Kbytes of RAM. I will present MicroPython in terms of hardware and software, including some boards with network access, like WiFi, Bluetooth and LoRa. But even with these hardware constraints, scientific MicroPython is already available and practical, to be shown from the perspective of users and developers.

MicroPython is a implementation of Python 3 optimised to run on a microcontroller, created in 2013 by the Physicist Damien P. George. The MicroPython boards runs MicroPython on the bare metal and gives a low-level Python operating system running interactive prompt or scripts.

The MicroPython boards currently use 32 bit microcontrollers clocked at MHz and with RAM limited to tens or hundreds of Kbytes. These are the microcontroller boards with official MicroPython support currently in the beginning 2017 : Pyboard, Pyboard Lite, WiPy 1/2, ESP8266, BBC Micro:bit, LoPy, SiPy, FiPy. They cost between USD3-40, are very small and light, about some to tens of mm in each dimension and about 5-10 g, have low power consumption, so MicroPython boards are affordable and can be embedded in almost anything, almost anywhere.

MicroPython boards have many electronic interfaces : digital input/output (GPIO) ports, analog inputs (via Analog Digital Converter), analog outputs (via Digital to Analog Converter), wireless (WiFi, Bluetooth, LoRa), etc. So MicroPython on these boards can be used to control all kinds of electronic projects.

In terms of hardware, 2016 was the year of MicroPython, as new boards compatible with MicroPython arrived : ESP8266 boards (there are more than 10 types, with WiFi), BBC Micro:bit (with Bluetooth LE, free distributed to 1 million British students of 11-12 year-old), LoPy (with LoRa, WiFi, Bluetooth LE), SiPy (with Sigfox, WiFi, Bluetooth LE). Even a 5 network board was announced for April 2017 delivery, FiPy with LoRa, Sigfox, cellular LTE-CATM1/M2(NBIoT), WiFi, Bluetooth LE.

In terms of software, MicroPython allows microcontroller programming directly with Python 3, which is easier and more productive than programming with Arduino IDE, C/C++, etc. And MicroPython is well suited for Internet programming, so MicroPython boards are a natural choice for IoT (Internet of Things), for example running a simple web server to show a sensor output (text and graphics), sending sensor data to IoT cloud, etc. This fact is very important as today there are some billions of IoT devices worldwide, and in 2020 some tens of billions are expected.

Even with RAM constraints (tens to hundreds of Kbytes), scientific MicroPython is not only possible, but already available and practical to use, with MicroPython modules capable of numerical calculations, FFT (Fast Fourier Transform), calculations with uncertainties, etc. I will list the scientific MicroPython modules which are available, as well as show how to port Python 3 modules to MicroPython, squeezing the source code in tens of Kbytes.

Some hints will be given to the FOSS community to be open minded about MicroPython : be aware that MicroPython exists, MicroPython is a better programming option than Arduino in many ways, MicroPython boards are available and affordable, porting more Python 3 scientific modules to MicroPython, MicroPython combines well with IoT.

The crash reporter showed that the LibreOffice project has a serious update problem with users using old versions and not updating to newer versions. The talk will present the work on the automatic updater as well as the approach to collect some user statistics to improve the crash reporter.

Based on the Mozilla updater code an automatic updater has been under development for the LibreOffice project for quite some time. Based on the experiences with the crash reporter the need for an automatic updater has been shown to be a serious problem for the project. The talk will show the current approach used in the automatic updater code, open challenges and how this allows to rethink the installation and packaging experience. Based on the prototype server the talk will also show how the server can be used to generate am estimation for active daily users (ADU) and how the information about the number of ADU can be used to enhance other services.

With the introduction of the Jigsaw module system many projects are confronted with issues running their code, now throwing new Exceptions like InaccessibleObjectException because they used to work around issues in the Java API. Although many features like the famous sun.misc.Unsafe are now provided by other public APIs, there is still the problem of making your code work with previous Java versions, but also dynamically using the new Java 9 replacements. Apache Lucene, the open source fulltext search library behind Apache Solr and Elasticsearch, is also using some of those "hacks" to work around issues in the Java API, but the developers also noticed that some code in the project hit some limits introduced by the module system. This talk will show on some examples how Apache Lucene managed to allow its code to run with different java versions (without using multi-release JAR files, as this brings additional burden with the build system) and still offer backwards compatibility to earlier versions. It will show also the common pitfalls that can be easily found with running your tests in a security manager to uncover bugs.

In the system administration world, Ansible is a well know tool used to deploy and manage systems easily and seamlessly. However, few people know this can also be used by network engineer to manage manage all kind of switches and network equipement thanks to the flexibility of the agent-less design. This in turn open the doors of automation of the network layer without the disruption of a complete SDN solution, permitting to adopt modern best practices of management with small step, and starting the culture change required for embracing SDN.

The talk will quickly present Ansible, its principles, and how you can use it to manage a simple server. Then we will go deeper in the topic of network, the philosophy behind the network modules, their limitations, and how to use them.

A look at how HTTP/2 has improved the web, which cases that are still problematic and what's being done about it next. Will there be a QUIC fix?

A recap on what HTTP/2 brought that HTTP/1 couldn't offer before we dig in and look at some numbers that show how HTTP/2 has improved (browser) networking and the web experience for people.

Still, there are scenarios where HTTP/1's multiple connections win over HTTP/2 in performance tests. Why is that and what is being done about it? Wasn't HTTP/2 supposed to be the silver bullet?

A closer look at QUIC, its promises to fix the areas where HTTP/2 didn't deliver and a check on where it is today. Is QUIC perhaps actually HTTP/3 in everything but the name?

Depending on what exactly happens in this area over time until FOSDEM, I will spice it up with more details on how we work on these protocol things in Mozilla/Firefox!

Nix is a package manager providing a number of unique features to automate deployments in a reliable and reproducible way. It serves as the basis of the NixOS Linux distribution (that can be automatically installed from a single declarative specification), as well as a number of additional deployment solutions, such as NixOps, that deploys virtual machines in the cloud and Hydra: the Nix-based continuous integration server. Although Nix offers all kinds of deployment benefits, integration with language-specific package managers that also do dependency management, such as the NPM package manager, is problematic as they conflict with Nix's reliability properties. In this presentation, I will show node2nix, a tool that automatically generates Nix expressions (build recipes) from an NPM package's package.json configuration file, allowing users to deploy NPM packages with the Nix package manger alongside other types of packages (e.g. Autotools, Perl, Python, ...) that constitute a large complex system.

In this talk I try to address the following target audience:

• System administrators/DevOps:
  • people who typically deploy entire software systems in which parts of them might be Node.js applications
  • NPM makes it less convenient to use a single intergrated deployment solution, e.g. you might need to use both NPM and the host system's package manager + additional scripts
  • solution requires on external distribution channels
• Distro packagers:
  • Some types of software are hard to package and as a result difficult to include with e.g. a Linux distribution
  • Especially if source package uses a system that does both build and dependency management
  • The Dependency manager conflicts with the host system's package manager and might use inferior technology
  • Besides NPM, Apache Maven is also a prominent example
• Node.js developers:
  • Many Node developers are not aware of some of NPM's dependency management implications
  • Good to raise awareness
• Package manager developers (e.g. the NPM devs):
  • Virtually every modern programming language/environment has its own (language-specific) package manager
  • Lessons learned are important for everybody

Implementing use cases on unified data platforms. Having a unified data processing engine empowers Big Data application developers as it makes connections between seemingly unrelated use cases natural. This talk discusses the implementation of the so-called BigPetStore project (which is a part of Apache Bigtop) in Apache Spark and Apache Flink. The aim BigPetStore is to provide a common suite to test and benchmark Big Data installations. The talk features best practices and implementation with the batch, streaming, SQL, DataFrames and machine learning APIs of Apache Spark and Apache Flink side by side. A range of use cases are outlined in both systems from data generation, through ETL, recommender systems to online prediction.

Session type Lecture

Session length 30 min + 5 min discussion

Expected prior knowledge / intended audience Basic exposure to Big Data Systems

Speaker bio Márton Balassi is a Solution Architect at Cloudera and a PMC member at Apache Flink. He focuses on Big Data application development, especially in the streaming space. Marton is a regular contributor to open source and has been a speaker of a number of open source Big Data related conferences including Hadoop Summit and Apache Big Data and meetups recently.

Internet Transport is changing, some changes have been incremental updates to mechanisms (e.g., RACK, BBR), others demand new protocol options (e.g., MPTCP) or entirely new protocols (e.g., QUIC, SCTP). However significant changes are still difficult to deploy - requiring modifications to application code and support by the stack. Even when updates happen, the network needs to support the new method to allow applications to use it. Long deployment times have motivated the need to change how protocols are handled in the stack. We review the state of the art in Internet Transport, and the status of deployment in th BSD's and then propose a new direction for the transport interface, developed in the EU NEAT Project, that can ease deployment of new transports across all platforms. We conclude by showing the advantages and its prospects for standards adoption.

MySQL Group Replication implements a "synchronous" replication protocol built upon a Group Communication Framework which is responsible for disseminating transactions to a set of MySQL instances and for managing their membership.

In this talk, we are going to present the framework's key properties and also detail the design decisions made to efficiently handle group replication demand for a high throughput and low latency communication infrastructure. Moreover, we are going to bring forth the main differences between our solution and mainstream algorithms such as classic multi-paxos and raft.

s6 is the most modern of the "daemontools family" of process supervision suites. It is used to provide lightweight multi-service container images, or extremely fast init systems on real machines - smaller, simpler, faster, and more reliable than systemd. This presentation explains what process supervision is, why it is a good pattern to have, how s6 implements it and how you can use it to your advantage.

What does sysvinit do? Why are gettys treated differently in /etc/inittab? What is process supervision? What is s6 and how does it work? What is a service manager? How can I use s6 today to run my services? How can we overthrow systemd and rule the world?

All these questions find their answers in this lightning talk!

This talk was moved backward one hour from its original timeslot (15:45).

SatNOGS: An SDR-based Satellite Networked Open Ground Station

Bareos (Backup Archiving Recovery Open Sourced) is a reliable, cross-network open source software for backup and recovery of data for a large set of operating systems (Linux, Unix, Windows, MacOS). Bareos offers a lot of tools for user interaction. The best known tool is the bconsole, offering a command line interface. While it offers a lot of functions and can also be scripted, the Bareos JSON backend is much easier parse-able, especially when using the bareos-python module.

This presentation will show, how Bareos can be scripted. It will give a overview about the existing tools (bconsole, bls, bscan, bareos-dir, ...), with special focus to the Bareos Console. It will show the Bareos Console feature, like commands, ACLs, JSON backend and scripting abilities. Especially for the JSON backend, we show how this can be accessed by the python-bareos module.

I worked on “Port NMatrix to JRuby” in the context of GSoC 2016. The performance of NMatrix-JRuby is outstanding even without making use of JRuby threading capabilities. Also, I am working on ArrayFire gem that helps in easy GPU computation and is 1e4 to 1e7 times faster than NMatrix gem

JRuby is known for performance. NMatrix, a linear algebra library, now supports JRuby. All SciRuby gems that depend on NMatrix can now be run on JRuby. A scientific library must be highly efficient as the programs can be memory intensive. The programs must be fast at the same time. This calls for optimization.

Suppose, you are running a Ruby program and you need to make it faster; you use threads, yet you are not happy with the results! Just chain the Ruby methods to Java methods. Using Java method can improve the speed, around 1000 times when compared to using Ruby method. Not only speed, it can help you save a lot of RAM, around 10 times. JRuby’s Garbage Collection can sometimes slow down your program if you are not careful with handling a large amount of data.

I would also like to share about ArrayFire gem that would be soon available for MRI that can be used for high-performance GPU computing using OpenCL/CUDA.

In the modern real time communication world, WebRTC is being paired with multiple channels and services to provide an unparalleled customer experience. Utilizing automated speech recognition allows us to build advanced assistive services such as real time captioned phone calls for hearing impaired people, simultaneous translation tools and automated bot assistants. All of that can be achieved leveraging modern open source software such as Adhearsion, the Ruby telephony application framework, FreeSWITCH, Flite, PocketSphinx and (optionally) external APIs such as IBM Watson. Our experience in developing that kind of service will be presented and discussed, plus code samples and a live demo.

Wrapping FreeSWITCH's WebRTC capabilities with Adhearsion acting as the call logic and the "glue" between parts makes creating rich ASR-enabled applications easier. Adhearsion allows you to leverage the full power of Ruby to access APIs, send messaging and updates, and use databases. Integrating FreeSWITCH with third party APIs who do not provide a direct interface, such as IBM Watson and Wit.ai, through Adhearsion and Ruby. ASR and sentiment analysis will provide our IVRs with an unparalleled ability to not only understand what callers say, but also what their desires and intent are. Dialplan applications can be complex to set up to use those APIs, and web applications are not well suited to that type of application. Adhearsion, the Ruby voice application framework, makes it easy and fun!

The LibreOffice project has become a large software development project. To better understand how it is being developed, a software development analytics dashboard has been deployed for it. This dashboard tracks most of the public data about LibreOffice development, and it allows to visualize, drill down and understand that data. The talk will present this dashboard, and will explain how to interpret the data it provides.

The Document Foundation Development Dashboard visualizes data obtained from some systems used to support LibreOffice development: git, Gerrit, Bugzilla... The data is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Document Foundation Development Dashboard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

We want the free software movement to keep growing and one facet of successful movement building is embracing a multi-generational community. The good news is that there is no age requirement for using, promoting and contributing to free software. The bad news is that we aren't always doing a great job of facilitating a diverse, inter-generational movement. We'll take a look at what we're currently doing to bring in young people, how we are treating older people in our communities and where there is room for improvement.

Using examples from other movements and inter-generational communities, we'll identify tactics that aren't being used to build the free software community and see what we can collectively port over. We plan to inspire the audience to find ways to recruit and retain young people, inspire older people to participate and maintain an unbroken thread of free software conservatorship.

The wide adoption of configuration management and the increasing size and complexity of the associated code, prompt for assessing, maintaining, and improving the configuration code's quality. This talk introduces configuration smells, their types with various examples, tools to detect them, and suggestions to refactor them.

The wide adoption of configuration management and the increasing size and complexity of the associated code, prompt for assessing, maintaining, and improving the configuration code's quality. We can leverage traditional software engineering knowledge and best practices to develop and maintain high quality configuration code. This talk brings the smell metaphor to configuration domain. This talk introduces configuration smells, their types with various examples, tools to detect them, and suggestions to refactor them.

The OCF/IoTivity project aims to answer interoperability issues in the IoT world from many different contexts to accommodate a huge range devices from microcontrollers, to consumer electronics such as Tizen wearables or your powerful GNU/Linux system The vision of Iotivity is not restricted to ad hoc environment but also can be connected to Internet and make the service easily accessible by other parties. With cloud access in place, usage scenarios for IoT devices can be enriched immensely.

In this talk we walk through the steps on how to practically handle IoT use cases that tailored towards various topologies. To introduce the approach used in IoTivity, we first give a detailed background introduction on IoTivity framework. Then we will present a demo that shows a few examples, from setting up a basic smart home network to accessing the IoT resource via a third party online service. Challenges and solutions will be addressed from development and implementation aspects for each step of the demo.

We hope this talk will inspire developers to create new IoT prototypes using FLOSS,.

This will be a shared presentation with Ziran Sun from Samsung Open Source Group.

The FOSDEM Networking team has managed the network for FOSDEM since its early days. Through our time operating this network, we have learned a few things about keeping networking up for a large group of highly-connected hackers, without an SDN controller managing the network.

We discuss how you can get traffic and monitoring information out of traditional routers and how to program them using NETCONF/YANG.

The workloads and scenarios for virtual machines grow more complex every year. So do the interactions, availability, and performance requirements. All that requires the administrators to carefully plan where to start the VMs that depend on each other and/or specific hosts.

This talk will present the concepts that allow the administrator to express the rules for affinity between virtual machines and between virtual machines and hosts to form complex relationships that will cover for example:

• licensing rules - limiting group of VMs to only use certain hosts
• overhead - web + database VMs running together
• performance - eg. storage VMs running on hosts with better IO performance
• failover recovery - VMs returning to “their” hosts
• reservation - There is place for only one of us!

oVirt is an open source project for managing virtual data centers that will now help the administrator with exactly the above tasks. We have introduced the virtual machine affinity feature in the past and a huge improvement in that area is coming right now.

And the best part is that all this works in a fully dynamic environment with automatic conflict resolution and no manual management of host pinning rules, saving the administrator his precious time.

Libreboot is free/opensource boot firmware for laptops, desktops and servers, on multiple platforms and architectures. It replaces the proprietary BIOS/UEFI firmware commonly foundin computers.

Libreboot is a free/opensource boot firmware implementation for laptops, desktops and servers, on ARM and x86 (POWER8 and POWER9 is planned). It replaces the proprietary BIOS/UEFI firmware found in most PCs. We believe that this is an important goal to aim for, for reasons of security, privacy and freedom in the user's computing, where, if we are successful and thrive, more people can use systems which do not have malicious anti-features, invasive backdoors and other nasty quirks introduced by most modern proprietary firmware.

Libreboot started in December 2013, as a response to the lack of other similar projects. Its goal was (and is) to provide an easy way for the public to access free, libre computing. This includes the boot firmware, operating system, drivers, applications and everything else.

It is based on coreboot, but we are also interested in using other projects as upstreams aswell, for other hardware. Libreboot is currently expanding, with an explosion of new hardware support on the horizon.

Libreboot was also a GNU project, for a brief period, but it voluntarily left the GNU project over a fundamental disagreement with the FSF, regarding their employment practises. Libreboot is now its own independent project once more, with its own community and infrastructure.

The libreboot project is always looking for more people to get involved, especially skilled hardware hackers (companies welcome) who have experience or knowledge in low-level firmware development.

Libreboot is funded by Minifree, which sells systems with Libreboot and Debian preinstalled. https://minifree.org/

The Unix dgsh shell provides an expressive way to construct sophisticated and efficient data processing pipelines using standard Unix tools, as well as third-party and custom-built components. Dgsh allows the specification of pipelines of non-uniform non-linear operations. For example tee can feed three processes whose output can then be collected by paste. The pipelines form a directed acyclic process graph, which is typically executed by multiple processor cores, thus increasing the task's processing throughput. We will see how to use dgsh in practice through a number of general data processing and domain-specific examples, and how to adapt tools for use with dgsh.

According to Andrej Kaparthy, there are four main factors holding back AI: Compute, Data, Algorithms, and Infrastructure. In this talk, we will show how we attack the Data and Infrastructure challenges for Deep Learning. Specifically, we will show how we integrated Tensorflow with the world's most scalable and human-friendly distribution of Hadoop, Hops (www.hops.io). Hops is a new European distribution of Hadoop with a distributed metadata architecture and 16X the performance of HDFS. Hops also includes a human-friendly UI, called Hopsworks, with support for the Apache Zeppelin Notebook. We will show how users can run tensorflow programs in Apache Zeppelin on huge datasets in Hadoop. Moreover, we will show how Hopsworks makes discovering and downloading huge datasets a piece of cake with peer-to-peer sharing of datasets between Hopsworks clusters. Within minutes, you can install Hopsworks, discover curated important datasets and download them to train Deep Neural networks using Tensorflow. Hops is the first Hadoop distribution to support Tensorflow. Hops and Hopsworks are both Apache v2 licensed projects and have been developed primarily at KTH Royal Institute of Technology and SICS Swedish ICT in Stockholm.

According to Andrej Kaparthy, there are four main factors holding back AI: Compute, Data, Algorithms, and Infrastructure. In this talk, we will show how we attack the Data and Infrastructure challenges for Deep Learning. Specifically, we will show how we integrated Tensorflow with the world's most scalable and human-friendly distribution of Hadoop, Hops (www.hops.io). Hops is a new European distribution of Hadoop with a distributed metadata architecture and 16X the performance of HDFS. Hops also includes a human-friendly UI, called Hopsworks, with support for the Apache Zeppelin Notebook. We will show how users can run tensorflow programs in Apache Zeppelin on huge datasets in Hops Hadoop. Moreover, we will show how Hopsworks makes discovering and downloading huge datasets a piece of cake with custom peer-to-peer sharing of datasets between Hopsworks clusters. A new user can, within minutes, install Hopsworks, discover curated important datasets and download them to train Deep Neural networks using Tensorflow. Hops is the first Hadoop distribution to support Tensorflow. Hopsworks itself is a self-service UI for Hops Hadoop, that is based around projects, users, and dataset concepts. Users collaborate in projects that contain datasets. Data owners can give users access to process data (but not download it, copy it outside of the project, or cross-link it with data outside the project). Hopsworks, thus, provides stronger access control guarantees than are available in Hadoop, enabling senstive data to securely reside on shared Hadoop clusters. Since April 2016, Hopsworks has provided Hadoop/Spark/Flink/Kafka-as-a-service to researchers in Sweden from the Swedish ICT SICS Data Center at www.hops.site.

Hops and Hopsworks are both Apache v2 licensed projects and have been developed primarily at KTH Royal Institute of Technology and SICS Swedish ICT in Stockholm.

With Mozilla shutting down its Persona web login service in late 2016, a pretty decent solution for logging into small websites became unavailable. The problem that Persona set out to solve is not gone, we still need solutions to log into all kinds of sites without a few central and big players analyzing all data about when and where we log in. I ran into that issue for my sites as documented in my blog - this talk will discuss the problem itself and my solution to it. This may include opening up some source code to the public!

Recent DDoS attacks powered by embedded devices have finally discredited the old excuse that security is not important: security support (and thus software updates) is suddenly a required feature.

Often, physical access to these devices is limited and there is no administrator who can fix issues manually. Thus, performing updates is an operation with a critical design goal: Never brick the device!

This talk gives an overview of the surprisingly complex requirements and common pitfalls for a generic update mechanism by comparing several existing approaches. Also, our reasons for implementing (yet another) tool and the reasoning behind the design choices are explained.

Using RAUC and other open source update tools as examples, requirements, limitations and possible pitfalls in the process of designing and implementing a redundancy and update infrastructure will be presented. You will also get a brief overview over RAUCs design and abstraction of the underlying system that allows to manage both simple asymmetric setups consisting of a full system and an initramfs-based recovery system as well as complex setups with multiple root filesystems, application and data storage partitions.

• How to make updates atomic?
• How to manage both simple and complex redundancy concepts?
• How to allow secure and trusted updates?
• How to schedule updates to a large number of devices?

Graph databases come with enhanced connectivity of data and whiteboard friendly paradigm. It requires learning a new Graph Traversal Language, that crawls the network and brings informations. It's indeed a fresh new look at how we store web of data and search for it. We'll meet gremlin, from Apache TinkerPop, which provides an abstract layer that make it easy to express your business logic without fighting with the code, and several Open Source graph databases, available for testing and toying.

MySQL Group Replication brings together group communication techniques and database replication to build a resilient, highly available database service. Fault-tolerance comes, however, at the cost of complexity and extra work that the system itself has to do.

In this session, we will look at how Group Replication performs and how it can meet the most demanding performance requirements. We will also bring forth a few tips and guidelines to configure and manage it in the most optimal way. These may help you to set it up efficiently and meet your infrastructure requirements. At the end of the session you will have learned how to make the most out of the Group Replication plug-in in terms of HA while achieving good performance overall.

Tom Callaway, the Fedora Legal chair, will talk about the past, present, and future of licensing and legal issues in the Fedora community. Tom is not a lawyer, nor does he play one on TV, but he does consult with lawyers, and occasionally, go drinking with them. Bring your questions, and he'll do his best to answer them. I am not a lawyer, so nothing in my presentation should be (or could be) construed as legal advice.

Fedora, as the evolution of Red Hat Linux, is one of the oldest and most well known Linux distributions in existence today. For more than 10 years, I have been the Fedora Legal representative who investigates licenses, negotiates with lawyers, advises our community, and does everything in my power to not have to tell people "no" without a very good reasoning.

In my presentation, I'll discuss the past, present, and future of licensing and legal issues in the Fedora community (and beyond). I'm also happy to take questions from the FOSDEM audience as to why Fedora does what it does (or doesn't do what it doesn't do).

I am not a lawyer, so nothing in my presentation should be (or could be) construed as legal advice. I am however, a well informed hacker, and the editor/maintainer of possibly the largest list of FOSS licenses in existence.

The virtual file system (switch) is an instrinsic element of traditional operating systems and the majority of alternative OSes alike. For the most part, this is caused by existing applications that depend on the file abstraction and to some extent on a global view on system resources. In contrast, component-based OSes with strong security ambitions strive to apply the principle of least authority and shun one global view on the system. This was the starting for the VFS developments for Genode. The talk will present our design considerations and the current state of the VFS in Genode as a component and capability-based microkernel operating system.

The Document Foundation Development Dashboard shows detailed data about how LibreOffice is being developed. It also allows for drilling down, filtering, and understanding it. The talk will explore some of these possibilities, by showing how to look for specific data, for customizing the results, and for sharing the results with others.

The Document Foundation Development Dashboard visualizes data obtained from some systems used to support LibreOffice development: git, Gerrit, Bugzilla... The data is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard allows not only to browse the data, but also to drill down and play with it. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Document Foundation Development Dashboard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

The talk will explain how to interact with the data provided by the dashboard for finding any detail of interest. The talk will also provide hints on how to exploit the data behind the dashboard to obtain specific information.

In the era of docker, big data and micro services it is really important to distribute your applications reasonable across your cluster and keep a good overview of all of your applications. This fact is well addressed, but it would be great to utilize your cluster in that way, that you locate your data in the same cluster like the rest of your application landscape and share your physical resources all over your running applications, no matter if you are serving user requests, crunching data or calculating big graphs. For this reason we brought the awesome graph database Neo4j to run natively on top of Apache Mesos and DC/OS. In this session we will see how easy it is to install, run, operate and scale out Neo4j Causal Clusters on top of Apache Mesos and DC/OS and which possibilities you have spanning big graphs across your cluster.

This presentation introduces a new modular mechanism for implementing live state and event notifications within the context of Janus WebRTC server instances, for the purpose of allowing administrators and developers to monitor and handle WebRTC sessions more effectively.

Janus is a general purpose open source WebRTC server and gateway. It allows you to implement heterogeneous and complex WebRTC multimedia applications using the different functionality it provides as modules, and can interact with legacy technologies as well in the process (e.g., SIP or RTSP). An introduction to Janus was made ad Fosdem '16. This new presentation is aimed to address a new feature recently added to Janus, and currently being worked on in a separate branch that will soon be merged.

Specifically, a modular mechanism has been designed and implemented to allow modules to receive asynchronous and live events of several different types from Janus and its plugins, in order to then handle them accordingly. Notifications can be about whatever is happening in a Janus instance, e.g., Janus sessions/handles and their states, PeerConnections and their lifecycle (SDP exchanges, ICE and DTLS state changes, etc.), application plugin internals and related events, and so on. These new modules can then decide whether to just forward these events, or a subset of them, to an external backend for further processing, or process them themselves. Use case examples are simple debugging, live monitoring, troubleshooting, storing on DBs or other systems in a structured way, CDRs, etc. Within the context of Janus, this is particularly useful as so far the only API available to administrators has been a query/response API to monitor the WebRTC internals of Janus itself and a few other aspects, which limited the scope of what admins could do to effectively manage a Janus instance.

At the time of writing, a single module implementing this mechanism exists, one we implemented ourselves as a proof of concept and that simply forwards all events as JSON objects to an external web server. In the future more modules will be implemented to cover more practical scenarios, hopefully by third-party developers as well.

This talk will discuss the applicability and potential of tensor processing methods for signal processing algorithm implementation. It will consider both machine learning and non-machine learning signal processing applications and discuss how they can be efficiently implemented with TensorFlow and used quickly in conjunction with GNU Radio.

Event logging is important not only for IT security and operations, but also for business decisions. The syslog-ng application is an enhanced logging daemon, with a focus on central log collection. It collects logs from many different sources, processes and filters them and finally it stores them or routes them for further analysis. From this session you will learn (using examples from syslog-ng) why and how to parse important information from incoming messages, and how to route logs, feeding downstream systems using arbitrary formats. We will also discuss how the client – relay – server architecture can solve scalability problems. Also, I will present some of the recently introduced “Big Data” destinations of syslog-ng, which can help to scale your infrastructure even further.

Outline:

• what is syslog-ng
• log collection
• introduction to log processing
• filtering
• Big Data destinations
• log formats - the importance of name-value pairs
• message parsing (both unstructured and some structured message formats)
• formatting (templates, anonymization)
• log routing (optimizing analytics infrastructure)
• client (collection) - relay (processing) - server (storing, routing)
• summary

Come and hack on Valgrind together. Open discussion about small (or big) ideas to improve or change Valgrind.

Valgrind developers and users are encouraged to participate either by submitting ideas/suggestions or by joining the discussion. And of course by kindly (or bitterly) complain about bugs you find important that are still Not YET solved for that many years!?@!!!

Afterwards we will sit together and try to fix or implement some of the things discussed.

Discuss any kind of possible improvement (technical or functional) to Valgrind.

If you want to put something on the agenda please send a small description (one or two paragraphs) to the the moderator Mark Wielaard mjw@redhat.com with in the subject: "FOSDEM devroom discuss: ..." If you want to discuss a somewhat larger topic please do feel free to send two or three slides in advance.

Mark will collect ideas/suggestions/... and present these and coordinate the discussion (and keep track of the time, so every idea will be discussed).

Some discussion topic ideas:

• Release/bugfixing strategy/policy.
• Can we move to git yet?
• Valgrind and transactional memory.
• Making Valgrind really multi-threaded, parallelising Memcheck, parallelising the rest of the framework, and tools.
• Instant leak detector. Modify memcheck to report the last leaked pointer to a block. Integrate "omega" as a memcheck option or omega as a separate tool. http://www.brainmurders.eclipse.co.uk/omega.html
• Make Callgrind work sanely on ARM (and PPC). The Callgrind algorithm to track call and return is to be improved to work properly on these platforms. Is there a way to make this better? E.g. by having a fast way working in most cases, and rely on unwind info in the difficult cases. Can we detect at instrumentation time that an instruction is a difficult case?
• Packaging valgrind for distros, handling patches, suppressions, etc.
• 32-bit x86 vs modern instruction sets (avx, etc.)
• VEX is in theory cross-architecture. What would it take to make valgrind cross-arch? How about starting with i686 on x86_64?
• Which CPUID is it anyway? Valgrind isn't completely consistent in handling host CPU capabilities vs VEX emulation capabilities. What can we do to improve that? Make it user tunable?
• <YOUR SUGGESTION HERE!>

And now is the time on Sprockets when we hack!

One of the fundamental problems with UNIX-like operating systems is that they don't seem to make it easy and intuitive to develop applications that are strongly hardened against exploits through sandboxing. With CloudABI, we're trying to make this process a lot easier, by having an environment that is purely based on capability-based security.

In another talk in the main track I'm going to give a more general talk about CloudABI, explaining what the mindset behind the project. During this talk in the BSD devroom I want to focus on one specific aspect, namely how FreeBSD's runtime environment for CloudABI works.

CloudABI is a simplified POSIX-like runtime environment that is inspired by FreeBSD's Capsicum. It allows you to create programs that can solely interact with the environment through file descriptors (capabilities). Compared to traditional UNIX-like systems, this approach has three advantages:

1. It reduces the impact of exploits. If an attacker manages to take over control of a CloudABI application, it can only access those resources that the application was designed to use (for a networked service: typically an already bound TCP socket and some data directories). This is different from most traditional UNIX-like systems, where an attacker would gain access to all resources that the user running the application can access, which is very broad.
2. It makes applications easier to test. By knowing that an application can only access those resources that are provided explicitly, the entire environment in which the application runs can be customized for testing.
3. Similarly, it makes applications easier to deploy. This model tends to reduce the need for using containers and virtual machines. Applications can be started directly, while still providing the necessary isolation from the rest of the system.

An interesting aspect of CloudABI is that it's cross-platform. You can compile a CloudABI program once and run exactly the same executable both on FreeBSD, macOS and Linux. In this talk I want to focus on this specifically: how is FreeBSD capable of running these programs? Topics I'll be covering during this talk include:

• FreeBSD's image activator framework: the code that parses and loads executables.
• The ELF file format
• System calls and system call tables
• vDSOs: Virtual Dynamic Shared Objects

Security reasons and market demands dictate that software in a connected embedded Linux device should be updated regularly. Update on a package basis that is used by PC Linux distributions can be a security threat by itself on embedded devices. On the other hand, full fylesystem upgrade that is common in embedded field can be too wasteful for systems constrained in network bandwith and disk space. OSTree is a tool that allows for upgrades that are both incremental and atomic and as such perfectly fits the needs of embedded world.

Software updating is an essential feature for a connected embedded Linux device, even if it is not required by end users of the device, since responce to newly discovered vulnerabilities in critical Linux software should be as fast as possible. One approach that is widely used in Linux world is using a package manager that will download a package and take care of all the dependencies. Unfortunately, some dependencies and/or conflicts with other packages can not be noticed by repository mantainers. On a PC it would just lead to the necessity to revert the package back to the working version, but on an embedded device with no human operator it is not possible. Theoretically, number of system configurations is an exponent of number of packages one can install, which means that it is practically impossible to make sure that no combination will result in a broken system. In embedded world it is more common to update whole file system image atomically. Thus we can test system configuration before we distribute it to the devices. To allow for atomic switching between file tree versions, dual disk partitioning scheme is used: while Linux is running on a root file system stored in one partition, updates are written to another. When the whole new file system image is downloaded, Linux can switch atomically to it. The main drawback of this approach is that you actually have to download the whole file tree (which can be 100-800MB large in modern devices) for every update. You also can use only half of your available disk space at once.

OSTree was developed by GNOME team for the GNOME Continuous project and was not initialy intended to be used in embedded Linux. It stores all the data in a git-like object repository, but unlike git it is designed to store binary data and can deploy data as hardlinks to the objects in the repository, thus saving significant amount of disk space. Like git it allows to incrementally transfer data between repositories, thus making distribution of software updates possible. OSTree repository contains roughly three kinds of objects: commit, directory and file object. Every commit points to a directory tree and represents a version of file system tree. Commits can then be deployed to a dedicated area and the system can switch to a deployed file tree much the same way it would switch to another partition in dual-partition scheme. Since deploying files just creates hard links to the file objects in the repository, there is no data duplication.

These benefits come at a price: since deployed files are just hardlinks to objects in a repository, they can't be changed, as it would corrupt the repository and other deployed file systems. Therefore, a clear separation should be mantained between read-only data, such as executables and resources and writable data, such as temporary files, logs, configuration stored in /etc. These requirements are not too restrictive, for most use-cases it will just involve putting data in correct directories. An image class that thansforms an OSTree-ignorant file tree to appropriate form and BSP packages for some popular platforms (Raspberry Pi, Porter board, QEMU; minnowboard coming soon) were integrated into Yocto build process and are now available as a separate Yocto layer on Github [https://github.com/advancedtelematic/meta-updater]. It allows you to create OSTree-enabled image and a commit in your OSTree repository as a part of your normal build process (simply 'bitbake your_image').

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

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

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

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

Over the last couple of years, the OpenJDK Quality Outreach effort has become a good source of high quality feedback from many popular FOSS projects starting with JDK 7 Updates, JDK 8 and JDK 8 Updates. It now plays the same role for JDK 9.

  With a number of large changes being planned for JDK 9 that are

being developed through the OpenJDK community, reaching out to popular FOSS projects well ahead of a release and keeping them informed of upcoming changes, collecting as well as acting on their feedback created a great feedback loop.

  Today, around 80 open source projects and communities participate

in testing of early access builds of the JDK, reporting issues they find, and helping get them resolved in time. In this session, we'll look at some examples of how they have helped make JDK 9 better, and discuss how we can together improve the OpenJDK Quality Outreach effort for JDK 10.

An introduction to Discourse development for the non-ruby inclined where participants will leave with knowledge of how to set up their development environment, where they can contribute to Discourse within Mozilla and upstream, and how to ask for help if they get stuck.

A lot of components in the Kafka and hadoop ecosystem assume you are working with avro messages. In this talk I will highlight some of the advantages and challenges of stream processing with protobuf encoded messages, and why it might be worth using them.

A powerful feature of protobuf messages is its handling of unknown fields, and the ability to partially parse messages with different schema versions or no schema at all. This helps in stream processing when you don't actually need to know all message fields in order to process and forward them.

HOMER 6 allows users to Export, Analyze and Alert RTC and VoIP sessions in real time using popular Big-Data backends such as InfluxDB and Elasticsearch providing unprecedented flexibility and opening the way for new uses of the platform in larger ecosystems with business intelligence feeds.

For FOSEM we would like to excite developers - who have interest in working on use-cases for Smart Cities, Utility Companies and other large-scale infrastructure companies - for the Open Smart Grid Platform. The Open Smart Grid Platform is an Open source IoT platform for large infrastructures. The platform allows you to monitor and control hardware in the public space. With several (generic) functions ready to use, the main benefits of the Open Smart Grid Platform are: scalability & high availability, high security, its generic design, and no vendor lock-in.

Introduction The Open Smart Grid Platform is an open source IoT platform. The open smart grid platform is a generic IoT platform, built for organizations that manage and/or control large-scale infrastructures. The following use cases are now readily available: smart lighting, smart metering, tariff switching, and microgrids. Furthermore the following use-cases are in development: distribution automation, load management and smart device management. The architecture of the open smart grid platform is modular and consists multiple layers. External applications are connected to a service domain via the integration layer. This integration layer contains web services. The service domain manages all the business rules such as: "Can we allow this change?”. The core component routes the messages to the correct protocol adaptor and contains generic functions such as device management, time synchronization and firmware management. The protocol adaptors convert the messages to a protocol that is used by the smart objects. This message could be a switching command, for example.

The open smart grid platform is highly unique for embracing the open source approach and the following key features: • Suitable for scalable environments delivering high performance • High availability and multitenant architectures • Built with security by design and regularly tested. • It has a generic architecture. More use cases and domains are easily added to the platform. • The open smart grid platform is based on open standards where possible.

More information can be found on: http://opensmartgridplatform.org/ and http://documentation.opensmartgridplatform.org/

Proposal talk For FOSEM we would like to excite developers for our platform by discussing the reasoning behind the platform from a technical point of view and the architecture of platform. We believe the platform is interesting for developers who have interest in working on use-cases for Smart Cities, Utility Companies and other large-scale infrastructure companies.

Redundancy is the prominent technique for creating resilient, highly available services. MySQL has had a quite mature and feature rich replication solution for over a decade now. Moreover, there are interesting new features that allow users to create quite advanced setups. Nowadays, there is group replication, multi-source replication, and of course plain asynchronous replication that allow users to create interesting new setups.

In this session we will present recommended ways to mix and match group replication with regular asynchronous replication. We will show how the user can combine both to create simple upgrade/migration paths to complex setups. We will also show specifically on group replication what is the recommended procedure to provision and deploy replicas and detail what happens behind the scenes when a replica joins the group.

Since June 2014 we face an EU directive that threatens all wireless devices. The Radio Equipment Directive requires all devices that are able to send and receive radio signals to be locked down. This goes much further than the FCC lockdown in the US since it doesn't only affect routers but also mobile phones, GPS receivers, and amateur radio operators.

From June 2017 hardware manufacturers will be forced to install technical measurements to protect the devices from being flashed with "non-compliant" software: firmware that hasn't been checked by the manufacturer to comply with applicable radio regulations (e.g. signal strenght, frequences). Many European states already have implemented the directive in national law without many ways how to circumvent the major lockdown.

However, we have identified possible ways how to excluded certain classes of devices from this directive. The speaker will evaluate the current situation, present additional findings and opinions of political and economic actors, and exchange ideas and knowledge with the audience.

More and more devices connect to the Internet and each other using wireless and mobile networks. These include countless devices such as routers, mobile phones, WiFi-cards and laptops. All of them, as well as all Internet-of-Things devices, today and in the future, fall under the regulation of the Radio Equipment Directive 2014/53/EU (hereinafter ‘the Directive’), adopted in May 2014 by the European Parliament and the European Council. The main purposes of the Directive are harmonisation of existing regulations, improving security of radio spectra, and protection of health and safety.

Many people agree to general purpose of the Directive. However, we express our concerns over the far-reaching consequences of Article 3(3)(i) of the Directive, which require device manufacturers to check each device software's compliance in order to comply with the Directive.

Threats of Radio Lockdown

We believe such requirement has negative implications on users' rights and Free Software, fair competition, innovation, environment, and volunteering – mostly without comparable benefits for security.

Article 3(3)(i) require device manufacturers to assess software for compliance with existing national radio regulations, a requirement which will keep users and companies from upgrading the software on devices they own, unless that software is assessed by the original manufacturer. This not only is a severe burden for device manufacturers themselves but also violating the customers' rights of free choice.

The requirement enshrined in Article 3(3)(i) will impact the freedom to conduct business of many companies relying on the abillity to provide alternative and Free Software firmware on devices. Alternative software is the foundation of many companies' products, and we should prevent economic disadvantages for these businesses.

Burdensome requirements to check every possible software's compliance will also have negative implications on innovation and charitable non-profit organisations who rely on software other than the manufacturers'. Efforts of volunteer associations helping people in need to connect to the internet, may be rendered void or severely handicapped.

Furthermore, alternative software on radio devices also promotes a sustainable economy. There are many devices still in working order which do not receive updates from the original manufacturers anymore, hence alternative software developed and improved by community efforts (such as Free Software) has a much longer support period which prevent users and customers having to dispose of still working equipment. In return, this also improves the security of users since older hardware still receives security updates after a manufacturer stops supporting those.

We are in favor of the Directive's aim to improve security of radio devices but not at the unbalanced expense of users' freedom and security in other areas. Firstly, upgrading the software of a device mostly helps increasing the devices' security. Secondly, we are convinced that such strict regulations are not necessary for typical consumer products with limited radio output power. And thirdly, we believe that such technical restrictions will not hinder people willingly violating applicable radio regulations.

Our Proposals

Therefore, we ask EU institutions and the Member States to take these concerns into consideration and ensure that the Directive does not place blanket, unnecessary and disproportionate restrictions on the rights of consumers and businesses when implementing the Directive into national legislations.

Describing the design and function of Weave Network Policy Controller, which uses iptables and ipsets to govern which Linux containers can talk to which other containers, under control of Kubernetes. The code is all written in Go, and available on GitHub under Apache Licence.

Kubernetes Network Policy is an abstract specification to define which connections are to be allowed within a Kubernetes cluster. Weave Network Policy Controller (weave-npc) is an implementation of this specification in Go, under the Apache Licence. This talk will describe the design of weave-npc; how it was built from existing components in Linux, Kubernetes and the wider Go ecosystem, how it integrates with the Linux network stack, and how it can be used to tighten security on a typical Cloud application.

An informal talk with ReaR, DRLM, and Bareos users about what they would like to get implemented in future ReaR, DRLM, and Bareos versions.

This talk happens at the end of the "Backup and Disaster Recovery" devroom time schedule. This way also new ReaR, DRLM, and Bareos users could first get informed about ReaR, DRLM, and Bareos so that afterwards they could better tell about what enhancements or features they would like to have implemented in future versions.

The introduction of non-volatile memory changes how applications, databases, and virtual machines will work in the future. NVDIMM is not simply a faster block device. Programs can avoid block I/O entirely and use byte-addressable NVDIMM to benefit from the performance characteristics of RAM. This requires new storage APIs that applications must use instead of traditional block I/O.

These new programs run successfully inside KVM virtual machines thanks to the vNVDIMM support already available in QEMU. Virtualization offers additional options for managing and using NVDIMM beyond what is available on bare metal.

This talk covers the NVDIMM programming model and how KVM virtual machines can use NVDIMM for faster I/O, reduced memory footprint, and faster boot times.

Xiao Guangrong recently gave a talk at KVM Forum covering the ACPI and hardware interface for NVDIMM under KVM. I want to follow that up with a talk for a wider audience of developers and system administrators who care more about the use of NVDIMM than its implementation.

This talk covers recent work on NVDIMM in QEMU and focuses on how applications can take advantage of this new class of storage device. It is suitable for an audience interested in storage or virtualization. Most of the concepts carry over to other hypervisors besides KVM.

Ruby and RaspberryPi are available to us for quite sometime and this talk is meant to discuss how to use Ruby to explore things on a RaspberryPi. From a practical point of view, we will go through installation, setup, and build a simple Motion Sensor application on a RaspberryPi.

In a world we teach ourselves a lot of things, why not do it Ruby & Pi way? Let’s get our hands on a piece of hardware, understand what it takes to setup one up, install a couple of libraries, Ruby, RVM, RBENV, a GUI. Let’s get a couple of sensors: motion, temperature, humidity, tsunami, ectoplasm and see if we detect a cool thing or two.

This talk will present a new method to estimate the bearing of a radio transmitter with a mobile, single-antenna receiver, and its implementation on a software-defined radio (SDR) testbed. The bearing estimation method relies on the following principle: by considering the signal received at several points along its trajectory, the receiver implicitly creates a virtual multi-antenna array (similarly to synthetic aperture radar systems) that can be used to estimate the bearing of the radio transmitter. Virtual multi-antenna arrays have two major differences with conventional multi-antenna arrays: 1) the position and orientation of each antenna in the virtual array depends on the movement of the receiver and must be estimated; and 2) the local oscillator (LO) offset between transmitter and receiver adds a phase offset to the signal received by each “virtual” antenna, which must be estimated and compensated for. The first problem is solved by using an inertial measurement unit (IMU), which can provide the relative position and orientation of the receiver for short time periods. The second problem is solved by expanding the signal model that is used in bearing estimation algorithms (such as MUSIC) to account for LO offset. The proposed system is implemented on a USRP-N210 SDR with an external high-end IMU and tested in an anechoic chamber. The SDR implementation is a mixture of FPGA and software development, while some parts of the data are processed off-line. The results show that our method is indeed feasible, with bearing estimation errors of only a few degrees. We then present the first efforts of an implementation on a USRP-E310 SDR which has an integrated, lower-quality IMU.

Cybersecurity is a broad topic and many commercial products are related to it. We demonstrate a fundamental concept in network analysis: re-construction and visualization of temporal networks. Furthermore, we apply the method to describe operational conditions of a Hadoop cluster. Our experiments provide first results and allow a classification of the cluster state related to current workloads. The temporal networks show significant differences for different operation modes. In reallity we would expect mixed workloads. If such workload parameters are known, we are able to handle a-typical events accordingly - which means, we are able to create alerts based on context information, rather than only the package content. We show an end-to-end example: (1) Data collection is done via python, using the sniffer script; (2) using Apache Hive and Apache Spark we analyze the network traffic data and create the temporary network. Finally, we are able to visualize the results using Gephi in step (3). In a next step, we plan to contribute to the Apache Spot project.

Expected prior knowledge / intended audience:

No special skills required, but minimal exposure to the Hadoop ecosystem is helpful.

Speaker bio:

Márton Balassi is a Solution Architect at Cloudera and a PMC member at Apache Flink. He focuses on Big Data application development, especially in the streaming space. Marton is a regular contributor to open source and has been a speaker of a number of open source Big Data related conferences including Hadoop Summit and Apache Big Data and meetups recently.

Mirko Kämpf is a Solution Architect at Cloudera and the initiator of the Etosha project. He holds a Diploma in Physics and worked on several projects related to complex systems analysis. His focus is on time dependent network analysis and time series analysis, using tools from the Hadoop ecosystem, and especially on the related metadata management. Mirko is actively using open source tools, author of several blog articles in the Cloudera engineering blog, and a speaker in Big Data related conferences and meetups.
https://de.linkedin.com/in/kamir

Links to previous talks by the speaker

Marton:

Hadoop Summit, Dublin, 2016 https://www.youtube.com/watch?v=mRhCpp-p11E

Flink Meetup, Berlin, 2016 https://www.youtube.com/watch?v=Rk8mVtGumPc&t=462s

Flink Forward, Berlin, 2016 https://www.youtube.com/watch?v=FtzXOLhZ-2c

Mirko:

Cloudera Technical Summit, Las Vegas, 2016 http://www.slideshare.net/mirkokaempf/from-events-to-networks-time-series-analysis-on-scale?qid=a3a3f939-19e4-4127-81a7-e963114d4110&v=&b=&from_search=1

GridKA, Karlsruhe, 2015 http://www.slideshare.net/mirkokaempf/apache-spark-in-scientific-applications?qid=b82c1d59-2098-409c-8b84-5570504c5546&v=&b=&from_search=4

GridKA, Karlsruhe, 2014 http://www.slideshare.net/mirkokaempf/hadoop-complex-systems-research?qid=a0eebdd3-b042-453d-9b65-a2e2301d09f8&v=&b=&from_search=6

Hadoop meetup, Munich, 2013 http://www.slideshare.net/mirkokaempf/munich-hug-20130522v2?qid=72841b48-efbf-442a-8b7f-0ea0db3b3ad4&v=&b=&from_search=5

Growing your real-time network infrastructure increases the pressure on backend services, especially billing, which becomes in most of the cases the bottleneck of the products offered. In this talk Dan will exemplify various mechanisms and strategies implemented in CGRateS for improving the speed of CDR rating and implicitly offloading the rest of components waiting for billing to occur. CGRateS is a battle-tested Online Charging System with support for Prepaid, Postpaid, Pseudo-prepaid and Rated charging modes.

Virtualization is one aspect of our everyday life where multiserver operating systems can shine. Given the right underlying architecture, one gets robust and fine-grained virtualization with little effort and code. Achieving the same on conventional monolithic systems requires careful and invasive changes to the whole system, and the security merely depends on the implementation at hand.

This talk describes and demos how both fine- and coarse-grained virtualization is implemented on the Hurd, and how virtualization helps users gain freedom #0, i.e. the freedom to shape her computation environment anyway she wants.

This talk presents OW2's efforts, experience, vision and methodology to assess the market readiness of open source softwa re. If ''open source software has won'' it remains that many conventional managers are not comfortable with it : rating open source market readiness can be a powerful tool to help decision makers. This presentation will cover: - the value chain of open source software : an analysis of what makes software valuable from the stand point of the end-user and what are the stakeholders in the value creation process; - the OW2 Open-source Sofware Capability Assessment Radar (OSCAR) platform, an open-source umbrella project implementing the OSCAR model by combining several open-source quality tools such as SonarQube, Fossology, ScanCode, Spago4Q, and outcomes from the RISCOSS European collaborative project; - the first version of OW2 OSS Market Readiness Level (MRL, derived from NASA's TRL or Technology Readiness Levels) scale derived from data ana analysis provided by OSCAR, a work in progress that we are happy to share with and submit to the audience.

This talk presents OW2's efforts, experience, vision and methodology to assess the market readiness of open source softwa re. If ''open source software has won'' it remains that many conventional managers are not comfortable with it : rating open source market readiness can be a powerful tool to help decision makers.

OSS is everywhere in our enterprise information systems and in nearly all the electronic systems we interact with daily, such as communication devices, cars, trains, healthcare systems, entertainment environments. With the increasing success of OSS software and in parallel the advent of OSS quality failures such as Heartbleed, the quality and sustainability of OSS components we use and produce is becoming progressively as important as the quality of the air we breathe.

OSS come in many different flavors. At OW2 identify three broad categories of projects. Those that are developed by a grassroot community, those that are essentialy developed and commercially supported by private companies and those that result from the collaborative efforts of ecosystems of commercial companies and research organisations. Our efforts aim at applying a common value chain analysis across the different categories enable to be able to compare them along a unified scale scale of market readiness levels. The growing number of companies that specialize in assessing open source software reflect how crucial this topic is becoming for the whole economy.

Initially derived from the seminal NASA's Technology Readiness Levels scale and inspired by, among others, the SEI Capability Maturity Model, several models and tools have been created in the last 20 years for describing and analyzing the quality and maturity of open-source software. These early models aim at capturing the projects' general software engineering quality drivers, their open-source related aspects such as their IP and community management. The most well-known initiatives include the Qualipso Open Maturity Model, the Qualification and Selection of Open Source software methodology, the Software Sustainability Maturity Model (OSS Watch), the NASA Reuse Readiness Levels and the PolarSys Maturity Assessment model. More recently, the Linux Foundation has launched the "Badge Program" project for drafting a new quality model for open-source software.

The existing models raise several questions: - first of all, theses models do not always follow the same pace as the IT world: several models were drafted in a pre-cloud, pre-devops, pre-heartbleed area and do not cover important aspects of modern OSS such as the ability to deploy easily a project into one or several cloud environments. - second, the models generally do not provide a reference implementation for feeding the data with open-source software and for providing both high-level and detailed quality analysis. - third, while it's easy to get a general consensus on software quality, divergences can appear when going into the details and attributing weights to the criteria, hence a need for a flexible model, - fourth, these models concentrate on the technical assessment of software and projects and their interest from the perspective of the contributor

This lightning talk will introduce: - our analysis the value chain of open source software: what makes software valuable from the stand point of the end-user and what are the stakeholders in the value chain; - the OW2 Open-source Sofware Capability Assessment Radar (OSCAR) platform, an open-source umbrella project implementing the OSCAR model by combining several open-source quality tools such as SonarQube, Fossology, ScanCode, Spago4Q, and outcomes from the RISCOSS European collaborative project. - the first version of OW2 OSS Market Readiness Level (MRL) scale derived from data ana analysis provided by OSCAR, a work in progress that we are happy to share with and submit to the audience. .

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

There is no de facto secured embedded Linux distro while the requirement is becoming more and more critical with raise of IoT in Industrial domains. When looking under the hood of the Yocto built AGL project, it is obvious that it can fit 95% of the most common requirements as a Secured Embedded Linux. We will look how non Automotive industries can easily reuse the AGL code and tools to build their own industrial product and why it's a safer bet than to build it internally.

Industrial IoT cannot be successful without a serious improvement of the security coverage. Unfortunately there is as today, no of-the-shelves offer and the skills required to create such solution, are at best rare, more often out of reach. AGL as created a customizable embedded Linux distro which is nicely designed for reuse in many domains outside of Automotive. During the presentation we will see how to: - start your development with boards readily available on the Net, - change the BSP and add peripherial using Yocto layers or project like MRAA, - integrate a secure boot in your platform, - add your middleware and your application without breaking the maintained Core OS - develop a UI on the integrated screen and/or an HTML remote brower - update the core OS and your add-ons. - get support and influence the project.

Do you remember the time you spent an afternoon putting print statements in your app trying to debug an issue and removed them before shipping the fix, only to add them back in a day later to work on another issue? Wouldn't it be great if those debug statements could just stay in your code forever? Like a little gift that keeps on giving, not just for you, but for everyone else on your team too.

That's what an application log is for! Logs aren't just for when things go wrong. They're for helping you to keep track of what's going on within your application.

We take a look at how you can add helpful messages throughout your codebase and leave them there, even in production! We'll cover common logging strategies, log aggregation and how to efficiently work with your logs to get the data back out again.

We'll also take a look at metrics solutions such as Graphite that can help augment your logs to help work out what was going on by correlating event logs with peaks/drops in other monitoring systems.

Upipe is primarily designed to be the core of a multimedia player, transcoder or streamer. The framework organizes the processing of incoming data buffer inside a pipeline of modules. It exposes core types for buffers and modules (called “pipes”), and the API of communication between pipes and between the application and pipes.

The meetup is for everyone interested in our project and community, to discuss the future orientations and problems.

For questions poke us on irc.freenode.net channel #upipe.

The leading configuration management tools, Ansible, Chef, Puppet, and others, are open source products, so active communities have formed around these technologies. The people participating in this community are one of the things that really stand out. When you ask about the best part of this community, the most common response is “the people,” since they tend to be welcoming, friendly, knowledgeable, and most importantly, helpful. The community certainly isn't perfect, and there are some challenges. This talk will cover a variety of wonderful and not so wonderful things about the configuration management community.

Diversity User Research: Becoming a Better Listener - Gloria Dwomoh

In order to understand the struggles and/or challenges of minorities in tech and foster a safe environment for their inclusion, we need to be better listeners. One way we are able to get access to the voice of our users is through user research. However in order to increase effective communication we need to learn the art of listening. Several of us were taught to speak, read and write, but we simply assume we know how to listen. There is a saying that less than 2% of people have had any formal education on how to listen, while that is a skill that many of us use in our daily lives. Through this talk we will understand the difference between hearing and listening; we will also explore active listening and how it can better help us in our user research.

Women in Open Source Technologies - Kristi Progri

The Gender Gap is one of the most talked topic since forever, and still a Gap. Where are the women in Open Source? Why is the gap so big? Women participation in open technology and culture is very important so we should all pay more attention. This talk will be focused on the large steps we can take to reduce this gap. Also we will share out experience at our hackerspace in Tirana, Albania since we have lots of women there.

Let's face it: Gender Diversity in Tech is in a quite bad shape. The sad thing about it is that it's even more noticeable in many Open Source communities in particular. But why is gender diversity important?

It’s not just diversity for the sake of diversity. If men and women are equally intelligent, statistically speaking, then out of the smartest ten people in the world, five should be male and five should be female. Thus, if your team is anything less than an equal balance of men and women, then your team is probably not the best it can be.

Unfortunately, if we take a look at a random sample from GitHub active contributors from 2015, just 5.4% of GitHub users with over 10 contributions are female.

Let's talk about the ways we can fix this and what efforts Mozilla does to improve this and how you can help Mozilla help the community, concretely with Womoz (Women at Mozilla) and the Diversity & Inclusion Team at Mozilla.

Large-scale data stream processing has come a long way to where it is today. It combines all the essential requirements of modern data analytics: subsecond latency, high throughput and impressively, strong consistency. Apache Flink is a system that serves as a proof-of-concept of these characteristics and it is mainly well-known for its lightweight fault tolerance. Data engineers and analysts can now let the system handle Terabytes of computational state without worrying about failures that can potentially occur.

In this talk, I am going to explain all the fundamental challenges behind exactly-once processing guarantees in large-scale streaming in a simple and intuitive way. I will further guide you through the tricks and pitfalls that we faced in our effort to make state management easy to use, transparent and yet extraordinarily powerful. Finally, I will demonstrate how you can declare state and the in-flight protocol that is running underneath your processing pipeline to guarantee that your computation will always run consistently and uninterrupted, until infinity.

In more detail I am going to demonstrate the basic and extended versions of ABS (Asynchronous Barrier Snapshotting) , our state-of-the-art decentralized, in-flight snapshotting algorithm tailored to the needs of a dataflow graph. ABS needs no global synchronisation and works purely in a decentralised manner. It is considered today as one of the most lightweight mechanisms for checkpointing application state and has been developed even further together with the rest of the Flink community with additional optimisations. In fact, other open source systems such as Apache Storm have also recently incorporated the same mechanism due to its simplicity and effectiveness. One of such optimisations that is currently being merged in the system, is the adaptation of the algorithm in graphs that contain cycles which I am also going to cover in this talk in more detail. Furthermore, I will also briefly explain our current efforts to incrementalize state snapshots to further balance the load trade-off of state checkpointing and recovery time.

Part of our job as package maintainers in various distributions is to ensure the binary packages can be built from the corresponding source code. This is often a requirement, either from a distribution's own policies (eg, the DFSG for Debian), or from the license of the upstream package (eg, the GPL). But although we are used to seeing .c and .py files as source, we sometimes forget that our packages are built from many other files for which we also must make the source available.

In this talk I will explain why we require source code in the first place; without the availability of source code, the whole free software ecosystem would not exist. I will also describe file types that we sometimes forget to see as source, or which are considered binary but we forget to include the source code for. This includes documentation, build scripts, files generated at build time by various programs, fonts, multimedia such as sound, music, images and even video. I will also describe various problems we can encounter when trying to determine what the actual source is, and that even if we know what the source is, that it is sometimes creates practical problems for distributions to include all of it.

Pieter Hintjens was a writer, programmer and thinker who has spent decades building large software systems and on-line communities, which he describes as "Living Systems". He was an expert in distributed computing, having written over 30 protocols and distributed software systems. He designed AMQP in 2004, and founded the ZeroMQ free software project in 2007. He was the author of the O'Reilly ZeroMQ book, "Culture and Empire", "The Psychopath Code", "Social Architecture", and "Confessions of a Necromancer". He was the president of the Foundation for a Free Information Infrastructure (FFII), and fought the software patent directive and the standardisation of the Microsoft OOXML Office format. He also organized the Internet of Things (IOT) Devroom here at FOSDEM for the last 3 years. In April 2016 he was diagnosed with terminal metastasis of a previous cancer.

Pieter Hintjens's website: http://hintjens.com

ZeroMQ: http://zeromq.org

iMatix: http://imatix.com

After 25 years of copyleft enforcement and compliance work, is copyleft succeeding as a strategy to defend software freedom? This talk explores the history of enforcement of the GPL and other copyleft licenses, and considers this question carefully. Attendees who have hitherto not followed the current and past debates about copyleft licenses and their enforcement can attend this talk and learn the background, and can expect to learn enough to provide salient and informed feedback of their own opinions about the processes behind upholding copyleft.

The first GPL enforcement action was done by Richard Stallman against NeXT Computers in 1989, regarding Objective C support in GCC. For 25 years, GPL enforcement has remained a regular but rarely mainstream activity in Open Source and Free Software projects. Very few projects enforce their copyleft licenses; most live with regular violations and merely ignore them, or simply beg violators to comply.

Even under the now-published and publicly discussed Community Principles of GPL Enforcement, co-drafted by Software Freedom Conservancy and the Free Software Foundation, GPL enforcement is regularly criticized and questioned. Those of us who enforce the GPL get wildly inconsistent feedback from the community: some copyright holders recruit organizations like Conservancy and FSF to enforce as much as possible, others often complaining that we simply don't enforce enough, and still others call for a complete moratorium on GPL enforcement.

Meanwhile, not all enforcement abides by community principles. For-profit enforcers, who have existed for decades, use copyleft licenses in a manner not intended by the license drafters: to captiously convince "customers" that they must buy proprietary licenses, or otherwise pay, to incorporate Open Source and Free Software into their products.

This complex landscape has become almost impenetrable for the average FLOSS developers who merely wish their code to remain forever free and libre. This talk will provide the basic history and background information about the state of copyleft in our community, and set the stage for all developers to give informed feedback to organizations that stand up for copyleft.

MyRocks is the RocksDB storage engine for MySQL. It will soon be available in proper distributions. I will explain when and why it can be useful. I will also cover the features it has, features we are working on and features it is missing. The short version of the story is that it provides the best space efficiency, better write efficiency and good read efficiency. But performance in practice has more nuance and I hope to help you to understand how to evaluate it.

RTC development is a very specialized topic. Developers working in this field often have to make a serious time commitment to know it well and keep up with all the new things that are happening. This implies that people need to focus on projects that pay their wages. The projects that pay are not always the projects that deliver the best results for the wider community though. In this session, we will look at the opportunities that crowdfunding and other schemes may provide to help RTC developers spend some of their work hours on projects for the greater good.

DCF-77 is a German very low frequency (VLF) emitter locked on the Cs clocks of PTB used for synchronizing radiofrequency-disciplined clocks found, for example, in low-cost weather stations. VLF signals propagate through the waveguide whose boundary conditions are defined on the one hand by ground, and on the other hand by the ionosphere (charged) layer altitude. In addition to the amplitude modulation of the Cs-locked DCF-77 frequency standard, a phase modulation is imprinted on the carrier for time of flight measurement, allowing for "precise" time of flight measurements. The topic of the presentation is

1. reception of the DCF-77 VLF signal using a coil antenna, with enough power to feed a lock-in amplifier and extract phase and magnitude information. When the reference signal of the lock-in is referred to a local Cs primary standard, day/night ionosphere altitude variations are readily observed -- here using the carrier phase analysis,

2. extraction of the time of flight through CDMA processing of the phase output from the lock-in amplifier, recorded on a (low frequency) oscilloscope, emphasizing the time resolution improvement of the phase modulation with respect to the amplitude modulation gained from the increased signal bandwidth,

3. replace the lock-in amplifier with software-defined radio processing of signals recorded with a personal computer sound card or the analog to digital converter (RTL2832U) of a DVB-T receiver dongle,

4. refer the second channel of the stereo sound card/DVB-T to a low-cost GPS 1-PPS time reference for local oscillator drift compensation, and hence measure the ionosphere altitutde variation through time of flight variation by comparing the phase-encoded cross-correlation peak position with the 1-PPS position, yielding results consistent with the lab-grade instrumentation.

Although the whole processing chain is trivial, various issues making its practical implementation challenging will be emphasized. Most significantly, the processing chain is very similar to those applied to GPS signals, yet easier to grasp with the strong VLF signal. We aim at analyzing the time stability of the phase modulated signal -- allowing for sub-100 us timing resolution -- and correlated observed phase fluctuations with ionosphere altitude

Find out why LXD machine containers should be part of your OpenStack cloud!

LXD provides Linux machine containers to users with the performance of bare metal servers and the security and flexibility of virtual machines.

By combining the LXD hypervisor with OpenStack (using Nova LXD) we can provide fast machine containers to users of a IaaS cloud with the same semantics and functionality of full KVM virtual machines.

This session will cover in detail:

The LXD hypervisor.

The Nova LXD integration of LXD into OpenStack.

Performance analysis of LXD vs KVM machines deployed as part of an OpenStack Cloud.

With DOM, software-defined architecture, advanced build tools, StackOverflow and ultra-high-level languages, main languages are still taught (and learned) via I/O operations, simple data structures, loops and switches, and little space to development and deployment environment advances and even algorithmic changes, like asynchronous running, that completely upend the way programming language, and programming, concepts should be assimilated. In this presentation I'd like to advocate for a multi-lingual, multi-paradigm, multi-tool approach to learning programming languages and how this could eventually be carried out.

The new century has seen an explosion of new ways of learning: through MOOCs, Webinars, bootcamps and incorporation of new technologies to learning. Still, syllabus of programming languages pretty much stays the same. There is enphasis in learning a single language (front end, back end, DSL) and a progress that goes from very simple input/output operations through some simple data structures to loops and other programming structures. This works usually well and the proof is all around us; besides, the ten first programming languages are the hardest, it is downhill from there. However, it could be much easier if we acknowledged the existence of this multi-environment (console, UI, web, embedded), multi-language (many languages in a single application, from data description to UI language), multi-tool (from simple compilation tools to deployment and monitoring tools) and organized our learning experience around it. And first we should use whatever we have on hand, like command-line interfaces (some of them with powerful languages) or even the browser itself, which always include a programmer mode. Also use visual languages like Scratch to teach more complicated concepts, as long as they are put into use with languages that can run the whole nine yards. In this lightning talk I will try to outline what would be the first basic steps in a course following these principles, and why I think this would lead to faster formation of programmers and the creation of a more adaptive mindset when tackling new careers or project in programming.

When working with BigData & IoT systems we often feel the need for a Common Query Language. The platform specific languages are often harder to integrate with and require longer adoption time.

To fill this gap many NoSql (Not-only-Sql) vendors are building SQL layers for their platforms. It is worth exploring the driving forces behind this trend, how it fits in your BigData stacks and how we can adopt it in our favorite tools. However building SQL engine from scratch is a daunting job and frameworks like Apache Calcite can help you with the heavy lifting. Calcite allow you to integrate SQL parser, cost-based optimizer, and JDBC with your big data system.

Calcite has been used to empower many Big-Data platforms such as Hive, Spark, Drill Phoenix to name some.

I will walk you through the process of building a SQL access layer for Apache Geode (In-Memory Data Grid). I will share my experience, pitfalls and technical consideration like balancing between the SQL/RDBMS semantics and the design choices and limitations of the data system.

Hopefully this will enable you to add SQL capabilities to your prefered NoSQL data system.

It will be interesting to see what happens if an established NoSQL database decides to implement a reasonably standard SQL; the only predictable outcome for such an eventuality is plenty of argument. - NoSQL Distilled, Martin Fowler - 2012

The Relational Databases (RDBMS) are an essential component of the computing ecosystem. Yet in the past decade we have witnessed a wave of alternative data management technologies often branded as NoSQL and BigData - an ambiguous and lacking prescriptive definition names.

To understand the NoSQL/BigData "movement" one need to understand the forces fueling it:

• The rise of Internet (Web, Mobile, IoT...) leading to Data {Volume, Velocity and Variety} challenges
• Object-relational impedance mismatch
• Cloud computing - Infrastructure Automation and Elasticity
• Shift from Integration to Application databases
• Data-Value vs. Storage-Cost Economics Shift

The various approaches in addressing those challenges have led to a multitude of over 150 commercially supported NoSQL/BigData platforms.

Such diversity means that an organization will adopt a mixture of data storage technologies for handling different circumstances (Polyglot Persistence).

How does an organization integrate the mix of data technologies?

To fill the gap many NoSql/BigData vendors are (or are considering) building SQL and SQL-based layers for their platforms.

It is worth exploring the driving forces behind this trend ...

After nearly a decade, the European Commission has presented its draft law for copyright reform. And it’s about time: our copyright laws are out of step with today’s technology. But the proposal to reform copyright lacks ambition, and is inadequate to address the today’s challenges. It even contains some very dangerous provisions - such as a snippet tax, and upload filters for online platforms - that would put the open internet, innovation, and creativity, at great risk. This session will unpack some of the key issues at stake in the reform and how you can get involved. Together we can achieve an EU copyright reform that fosters innovation and creativity.

In this session, I'll talk about how we migrated from InnoDB to MyRocks in production at Facebook, for both slave and master instances, without stopping services, without losing data, and without returning wrong results. We created many features for easier migration, such as fast data loading, online data correctness check tool. I will share with you about lessons learned from our initial migrations and impacts what we have seen.

Generic distributions such as Fedora, CentOS, RHEL and others have well defined update and security mechanisms as well as other processes that have been established and proven to work over a multiple decades. How can we make use of these positives of distributions along with modern tools and technologies to produce a secure, stable, scaleable OS for IoT products?

Telepathy Bell is a telepathy connection manager that enables a telepathy front end for Ring. Ring is a privacy focused communication application that uses a distributed peer to peer network for real time communications. In this talk, I would like to share my experience while creating Telepathy Bell.

The idea behind Telepathy is to unify all communications. Several communication services like IM, VOIP etc. implement their own desktop clients. This leads to duplication of effort and sometimes poor integration. Most of these features can be abstracted and their functionalities can be integrated to provide a unified user experience. A normal everyday user will use the telepathy client application to communicate. This could lower the entry barrier for many applications and make it convenient for the user to manage communication services in a single client application.

Through my talk, I would like to share my experience during GSoC and beyond of creating a telepathy connection manager for Ring.

Introduction of bibisco, a novel-writing application created with love by book lovers to inspire writers to create “beautiful” work.

bibisco is an open source application for writing novels hosted on github (https://github.com/andreafeccomandi/bibisco).

bibisco is available for windows, linux and mac and you can download it at: http://www.bibisco.com.

With bibisco you can organize chapters and scenes, manage revisions, export novel in pdf or rtf, and write with a fully featured text editor.

You can create a novel structure, define premise, fabula, plots and settings: geographic, temporal and social context.

bibisco provides you various statistics, such as who appears in which scenes, and where the scenes are located, which plots are used in which scenes, and how many words each chapter has.

And, most of all, with bibisco you can know everything about your characters, interviewing them.

Actually, bibisco has 40k downloads, is translated in 8 languages and is one of the 7 cool little open source projects that stood out in 2016 in the yearbook of opensource.com (https://opensource.com/16/12/yearbook-7-cool-little-projects).

Do you have phone numbers in email messages that you have never copied to your address book? Would you like a systematic way to find them and compare the to your address book?

This project worked for Google Summer of Code-2016 for Debian with the title "Improving voice, video and chat communication with free software", one of the Real Time Communication project. The first part of the project is email mining where the necessary data are extracted from the mail and to make into web interface.

Xen is a hypervisor using a microkernel design that allows running multiple concurrent operating systems on the same hardware. One of the key features of Xen is that it is OS agnostic, meaning that any OS (with proper support) can be used as a host. Xen has a long history going back to the 90s when it was designed and the early 2000s when it was released. As a consequence of this, many of the assumptions and virtualization techniques backed into it are now superseeded by new hardware features, that make virtualization more transparent from an OS point of view.

This talk provides an overview on the different kind of guests supported by Xen and how these new hardware features are used in order to improve and evolve them. It also describes the design and implementation of a new guest type, called PVHv2, and how it can be used as a control domain (Dom0).

The talk consists of an introduction to iChat gateway, tech and protocols used to build it, what new features are being build into it and why we should use ita and a working demo. It mainly shares my ideas and views on this project as that I gathered as I worked on it as part of GSoC'16.

The iChat-SIP gateway was designed to allow communication between a Apple iChat and standard SIP client, for audio calling purposes. It also provides the ability to register iChat users to a SIP registrar server for routing purposes. iChat uses normal XMPP for chat with non-standard extensions for voice and video. The reSIProcate iChatGW can be extended easily to enable chat messaging with any XMPP client but more significant effort is required to standardise the voice support. iChat have been discontinued by Apple and currently iMessage perform the same tasks with added features. The talk includes a demo of this project, starting from from setting it upon the server to successfully sending and receiving calls and messages. It also gives a brief details on the libraries used and on how these help in effective communication. It'll help more peole to get a head-start on this project, setup or contribute to the project or use the libraries and technology to build their on chat systems and set them up.

Closing session

Kamailio is an open source SIP (RFC3261) server that can be used for building real time communications systems for IP telephony, instant messaging or presence. Seeral years ago it introduced a Lua embedded interpreter to allow more flexibility in routing calls. Recently, it was extended to allow entire RTC routing logic to be written in Lua. This talk focuses on showing the insights of implementing the LUA RTC API in Kamailio, tips and tricks discovered to make it as fast as the native pre-compiled routing language, and the benefits it bring to enhance RTC systems and integrate with third party services, such as social networking platforms (e.g., sending a Twitter DM on a missed call).

Real time communications has evolved at a fast pace in the last decade. From what it used to be direct voice calls or testing via classic or mobile telephony, nowadays everyone connects through a multitude of channels, dedicated messaging systems or other social media channels. Kamailio is an open source SIP server developed since 2001, with an initial focus on scalability for IP telephony services. To allow more flexibility and easier integration with other RTC services, an embedded LUA interpreter was added to it and with a recent development, the entire SIP routing logic can be written in Lua. The presentation will reveal insights of implementing the LUA RTC API in Kamailio, tips and tricks discovered to make it as fast as the native pre-compiled routing language, and the benefits it bring to enhance RTC systems and integrate with third party services, such as social networking platforms (e.g., sending a Twitter DM on a missed call).

Very happy to see you again!

A huge number of mobile testing tools have been developed in recent years to support mobile development. As more companies are developing mobile products and the marketplace is seeing more devices, platforms, and versions, testing your mobile apps is vital. When it comes choosing what mobile testing tool is right for you, there is a huge array of options, each with different strengths and weaknesses.At same time there are lot of challenges involved in automating a mobile applications like inspecting the objects, parallel testing to make the product custom fit in agile life cycle, Native framework support, Wearables/tvOS support etc. And we are going to see how Appium with the help of other tools handles these problems to steal the future

Problems faced by Mobile testers and how Appium provides solution for it.

1) Xpath Locator Strategies - completely depending on the xml hierarchy that app renders

    - Locator strategies are quite improved by replacing the android-bootstrap implementation with actively maintained google’s droiddriver implementation to locate objects effectively
- Issue e.g Unable to select individual elements in UIATableView by Xpath -https://github.com/appium/appium/issues/6517
- add invisible elements to uiautomator2 page source https://github.com/appium/appium/issues/4369

2)Inspector:

- Limitation of Appium Inspector & Calabsh’s IRB - completely depends on the application page source rendered by either instruments UIAutomation or UIAutomatorViewer which in turn fails on many cases depending on the technology used  to develop app,instruments UIAutomation known issues which doesn’t render UITableCollectionviewcells often,not so user friendly,etc
- This been overcome by Facebook’s webdriveragent & its inspector which has more control over the device not just the application
    - appuim inspector isn't maintained. we recommend users inspect via uiautomatorviewer

3)UIAutomation support is over from Xcode 8 beta:

- Apple has lifted their support of UIAutomation from Xcode 10 hence automation libraries or tools depending on native framework won’t work from iOS 9.Apple has an alternative solution of XCUITests to automate app’s but the API’s of XCUITests are completely broken on many cases
- Facebook’s WDA uses XCUITest for automation which fixed many of broken XCUITest API’s
- Appium has already adopted FB’s WDA which inturn support’s future iOS automation through XCUITest Driver called appium-xcuitest-driver
- Instruments Memory leak will get over with this new approach

4)UIAutomator 2 Framework:

- Issues in Google’s Framework: UiAutomator V2 finding objects which are not identifiable with UiAutomatorViewer. https://code.google.com/p/android/issues/detail?id=207569
- uiAutomatorviewer not in sync with V2 implementation
- project architecture in appium
- https://github.com/appium/appium/issues/4869
- https://github.com/appium/appium/issues/4858
- -support Toast Messages on Android
-get the text from a password field

5)Handling Multiple Sessions at a time

- Parallel Execution on iOS real device
- Parallel Execution on iOS Simulators (Will be supported in upcoming versions)

This talk will be based on open source data manipulation and analysis python library – Pandas. It will mainly focus on exploring the most commonly used features of the library like – integrated indexing using DataFrame objects, slicing and subsetting of large data sets, merging, joining and size mutability of data structures, hierarchical axis indexing to work with high-dimensional data in a lower-dimensional data, flexible reshaping and pivoting of data sets etc.

This talk will be based on open source data manipulation and analysis python library – Pandas. It will mainly focus on exploring the most commonly used features of the library like – integrated indexing using DataFrame objects, slicing and subsetting of large data sets, merging, joining and size mutability of data structures, hierarchical axis indexing to work with high-dimensional data in a lower-dimensional data, flexible reshaping and pivoting of data sets etc.

We know the expression ‘Open Source’; what about ‘Open Design’? How could we define ‘Open Design’? Design creative process is not disclosed. The secrecy around it is of the utmost importance in order to prevent the original creations from being stolen. The different stages of the process and the techniques used are only known by those involved in the design. How could we call this stance into question and open the creative process? This talk will present existing initiatives and thoughts to make Graphic Design and Open Fonts fields more available to the public.

First I will introduce graphic designers and typographers who open their process: why do they share their practice? why is it interesting? how and why is it useful? I will talk about originality and copy: we should not be afraid of copying. Moreover copying can be an opportunity to improve the original design. About Mozilla rebranding: I will point out some suggestions to further that initiative. How could designers take part and get committed? Finally I will give designers food for thought to defend their work, explain and communicate it, and better collaborate with their team and people who are not designers.

GlusterD-2.0 (GD2) is a new implementation of the GlusterFS management daemon, which attempts to fix a lot of issues with the current management daemon.

This talk will give the listeners an overview of the problems that GD2 is attempting to solve and how it solves them.

GlusterFS is a highly modular distributed filesystem. The translator model used by GlusterFS allows new filesystem features to be easily developed and included in GlusterFS.

But the GlusterFS management daemon, GlusterD, makes it hard for developers to actually get their new features into the hands of end users. Almost any new filesystem feature needs to have code written for it in GlusterD to ensure it is actually available for use. GlusterD, unlike the rest of GlusterFS, is a single monolithic, with a very large, undocumented and hard to navigate code base. This makes it very hard for feature developers to integrate their feature in GlusterD. In addition to this, GlusterD makes it harder for GlusterFS to scale, harder to integrate with external projects and takes up a lot of maintenance effort.

GlusterD-2.0 (GD2) is a ground up re-implementation of the management daemon, designed from the beginning to overcome the above problems. GD2 and its internal frameworks are designed to be flexible, extensible and pluggable. GD2 makes it easier for developers to integrate their newer features into GlusterFS as well as allow easier integration of GlusterFS and other projects. In this talk, we'll be covering how GD2 and the new frameworks work to solve the problems above.

This talk will be useful for developers interested in working on/with GlusterFS, users who want to understand how GlusterFS manages itself and people with a general interest in management and distributed systems.

Software is (often) distributed as binary. But where is the corresponding source code? Given a binary, how can you find out which source code was used to compile?

Using advanced techniques and open source tools, we can find out which source code was built in a binary. The applications are important for FOSS license compliance and/or enforcement as well as general code hygiene and build sanity.

Can you tell exactly which files are baked into the binaries of the software you build and distribute?

There are many applications for this knowledge:

• facts finding for FOSS license compliance and enforcement.
• better control of what third-party code you use and depend on and their related FOSS license requirements.
• general software and build hygiene such as pruning obsolete or dead code.

With clarity on what's in your binary, you can better understand:

• if a file is really used or not and what it is used for.
• if and how files are linked together such as static vs. dynamic linking.
• if some extra files are pulled from network repositories at build time.
• what are your build and runtime dependencies.

We will review why this does matter, present available FOSS tools and techniques to get back to the corresponding sources from built binaries using dynamic build tracing and static analysis; and the applications, usage and caveats of these techniques for various programming languages and platforms.

So join me and let's find out what's in your binary!?

Monitoring can mean very different things to different people, and this often leads to confusion and misunderstandings. There are many offerings both free software and commercials, and it's not always clear where each fits in the bigger picture. This talk will look a bit at the history of monitoring, and then into the general categories of Metrics, Logs, Profiling and Distributed tracing and how each of these is important in Cloud-based environment.

Abstract: So you’ve containerized your application, and now you want to deploy it scalably across a cluster. Maybe you’ve looked at Kubernetes but you can’t figure out how to use it. In one short session, we’ll teach you enough to get started.

Abstract: So you’ve containerized your application, and now you want to deploy it scalably across a cluster. Maybe you’ve looked at Kubernetes but you can’t figure out how to use it. In one short session, we’ll teach you enough to get started. We’ll cover:

What is Kubernetes? Configuring your apps Creating a deployment Tools to help: Ansible, Kompose and OpenCompose Scaling an application Failover and HA A Kubernetes GUI: Cockpit

Container orchestration doesn’t have to be hard; let me give you a push in the right direction.

How do we decide when a discussion is complete? How do we know we've heard from enough people, or that the topic isn't dead yet? Deciding how to take decisions in a community is hard - in this talk, I'd like to ways to handle it.

Figuring out when to close a discussion is really hard - and more so if all the participants are only using forums/mailinglists/chat rather than being face-to-face. Knowing that you've heard from the right people, trying to ensure quiet voices are heard, and making sure you're not cutting the discussion too early (or too late) really matters. In this "talk" I'd like to bring some examples of such discussions from our community (e.g. things which caused conflict, things which caused communications blocks, and so on), talk about how we handled them, and discuss ways in which we could improve - hopefully to the benefit of everyone present.

Word of welcome

Gnucap, the GNU circuit analysis package, is a flexible mixed-signal circuit simulator with significant technical advantages over SPICE derivatives. One is modularity. Gnucap implements a dynamic loader for extesions adding language support or component models.

Recently, some of the extensions for an experimental fork have been adapted to the the main line. An overview over the development progress and available functionality will be provided. This talk will demonstrate the use of geda schematics and verilog device models in Gnucap driven circuit simulations.

Many people learn to code because they want to write a computer game. More often than not, they want to re-write their favourite game, but making it a little easier! Unfortunately the gap between a personal project, open source game, and professional offering is substantial, with the lack of polish obvious at every turn. In this talk, Steven Goodwin, a game developer of 20 years standing (and 3 books on the subject), dissects each discipline (art, music, writing, and code) to explain where polish should be added and why it’s so rare to see open source games as effective as their commercial counterparts.

In theory, an open source game should be much better than a commercial version. After all, as a group, we have more resources at our disposal, over more time, in order to build more assets, write more code, and fix more bugs. But that’s rarely true. Our efforts look rushed and amateur in comparison. After a brief discussion on the meta-problems of open source game development we look at each discipline and demonstrate what needs to be written to improve the game, details of simple, but effective, visual improvements that can be done with very little effort, and how certain functionality can be implemented in order to make a game shine. The talk also includes a checklist of features implemented in Space Bounce that, while you might not have noticed them, you would certainly realize if they weren’t there.

Surveillance: the case for personal Cloud and against GAFAMs

The concept of Personal Cloud

Demonstrating a personal cloud instance and its innovative usage.

Most of the Western population now uses 3 different kinds of computers: PCs, smartphones and Cloud services. Where is the room for Open Source and Free Software in this new world? Software freedom is possible on the PC side, it's already quite challenged on the smartphone world, and too little is being done on the Cloud side. A lot of Cloud services run on open source software, but offer in the end proprietary services that centralize user data. As Edward Snowden's revelations have demonstrated, all of this makes mass surveillance economically possible.

What do we do as a community to avoid mass surveillance? What alternative do we build?

One possibility is the Personal Cloud movement, where a server (self-hosted or not) runs a platforms that enables personal data collection through connectors in order to run innovative apps relying on that personal data.

During this short presentation, we'll see how data centralization leads to mass surveillance and how a personal cloud works.

Schema (http://schema.seyman.fr/bugzilla) is a web application that generates HTML documentation for the database schema of any version of Bugzilla, a web-based general-purpose bugtracker and testing tool. It leverages a number of well-known Perl modules (DBIC, Plack, Template, Dancer, ...) to do its job. Long-term goals are making Schema generic enough to cover the database schema of any application (not just Bugzilla) and show schema changes between any two versions.

In this presentation I will talk about Android (and a little of iOS too) development with Gomobile. What options do we have when it comes to mobile devices and our favorite language, how to start and a few bits about my experience building an Android App.

This will be a practical talk showing you how you can containerize/sandbox your applications without resorting to either LXC or Docker. You will learn how to use the combination of chroot, Linux::Unshare and Linux::Prctl to create simple yet powerful isolation for your applications. Finally you will also see how to enter in LXC/Docker containers without resorting to external applications. The main goal is to show you the steps you have to follow in order to make sure you build a good isolation.

Firewall, IDS, SELinux, ssh bastion, and others, the list of server side security measures is long. While servers can be reasonably secure nowadays, we always forget that there is always a way to enter by the desktop side. In this talk, we will explore various security measures to be used and deployed on a Linux desktop, and while it will be primarily focused on the Fedora distribution, lessons will be applicable to most Linux distributions and Unix systems.

The case of rapid prototyping of a small prototype for a server backend of a geolocation-based mobile game, using nginx, OpenResty, Redis and Docker will be examined in the talk. Topics will include: why was the technology stack selected, what are the advantages (and some disadvantages), the architecture of the prototype, and how the features of the stack were used in the implementation. Some words will be said on how to keep iterations on the prototype rapid and how to upgrade the project from the prototype to a production system.

Python and "the SOLID principles". This is an introduction to the first five principles named by Robert C. Martin (uncle Bob). These principles are the foundation of a good software architecture. We will have a look at how this applies to Python code. We will have a look at abstract base classes, dependency inversion and so on.

Python and "the SOLID principles". This is an introduction to the first five principles named by Robert C. Martin (uncle Bob). These principles are the foundation of a good software architecture. We will have a look at how this applies to Python code. We will have a look at abstract base classes, dependency inversion and so on.

As part of a log file monitoring tool, I implemented a file tailer that keeps reading new lines from log files. This turned out to be much more challenging than I thought, especially because it should run on multiple operating systems and it should be robust against logrotate. In this 20 Minutes talk I will present the lessons learned, the pitfalls and dead-ends I ran into.

The monitoring tool is https://github.com/fstab/grok_exporter

Slides: https://goo.gl/9ABX2R (docs.google.com)

Most small businesses have no patent strategy. Though many FOSS companies have policies in place regarding copyright and keeping detailed records of code contributions, few have paid enough attention to how patent litigation could affect them. For those FOSS businesses active in multiple countries or looking to expand into an international market, failure to understand the patent ecosystem in each jurisdiction could be a costly mistake.

Most small businesses have no patent strategy. Though many FOSS companies have policies in place regarding copyright and keeping detailed records of code contributions, few have paid enough attention to how patent litigation could affect them. For those FOSS businesses active in multiple countries or looking to expand into an international market, failure to understand the patent ecosystem in each jurisdiction could be a costly mistake.

This talk will use recent cases and ongoing changes in the patent systems of the US & Europe as modern examples for our discussion. We'll describe the pitfalls that can affect any company, tabulate the costs of litigation, and offer methods businesses can use to reduce overall risk.

With the future of the European Union's Unitary Patent Court in limbo due to the Brexit, and with no public position on patents from the United States' next administration, leaders in Free Software owe it to themselves and their companies to be more agile and more prepared to address patent issues -- whether they work at a small startup or at a large multinational corporation.

The German Weather Service (DWD) provides over 25 thousand climate time series from meteorological stations across Germany via an FTP server, but it is not always easy to find out which datasets are available. To facilitate file selection and (automated) downloads, I developed an R package that can be used to select, download, read and process weather data. The aim of the package is that researchers can focus on scientific problems instead of data management. At FOSDEM, I would like to present the main instructions for the package, how the FOSS community aided in putting it together, and give a brief outlook on the potential analysis types. The package is FOSS at https://github.com/brry/rdwd#rdwd

The talk will provide an overview of the features, tools along along with a few examples. I will present the latest developments and plans for the future.

Slides available at https://belenbarrospena.github.io/fosdem2017

The decision of creating a jobs board as part of the Open Source Design project was no doubt an excellent one. Our conversations during the first Open Source Design devroom showed that a place to match designers with FOSS projects was sorely needed. At November 19th, the jobs board has received 53 submissions. I consider this a success, given our limited reach and the small size of the Open Source Design initiative.

Going through the content of those 53 submissions shows a clear pattern: the overwhelming majority are looking for graphic designers, and many of them are asking for a project logo.

Although graphic design is absolutely fundamental to software, and branding elements such as logos help projects develop and strengthen their identity, user-centered design is much more than that, as the content of our devrooms illustrate. It is also important to understand that good graphic design does not exist in isolation: it is embedded within the work of other user-centered design disciplines and concerns.

User research, information architecture, interaction design and content strategy can make valuable contributions to FOSS projects. The question is, how? What needs to change for FOSS projects to identify the need of an information architect or a user researcher? Is it just about building knowledge and awareness about these branches of design? Or do these disciplines require some fundamental changes to the way contributions happen?

This talk is more about questions than answers. It will provide a brief introduction to the different "layers" of the user-centered design process as outlined by Jesse James Garrett (http://www.jjg.net/elements/pdf/elements.pdf), and will pose some questions about how to incorporate them into FOSS projects.

Finding the answers to those questions is one of the reasons why we need the Open Source Design community.

The decentralized social world is on. It's been four years since the project was transferred to its community. Discover with us what we accomplished and where we'd like to go.

We will present some typical community management worries about community health, productivity and visibility and how some open source tools could be used to face them. Open source development transparency allows community to behave as data scientists and extract valuable information.

During last years, we have seen the growth of an specific position in many companies and OSS foundations. You might have seen them as “community managers”, “developer advocates”, “developer relations”, etc. All of them share some goals / responsibilities in common with their communities: health, productivity and visibility. How to achieve them?

It has been said that “without data, you are another person with an opinion”, and management shouldn’t rely in opinions but facts. This path increases transparency, trust and reduces conflicts, since usually “numbers speak louder than opinions”.

If we look around in our daily live many of us are already working with tools for similar goals in different areas of life. We can wear heart rate monitors, check our activity in github or jira and play with zillions of marketing campaigning tools.

In OSS communities people “contribute” for a goal. So, we should start by looking at where people are contributing, and here starts the “community manager nightmare”. People contribute in a lot of places: github, gerrit, jira, mailing lists, slack, meetup, etc. It seems obvious which data sources we have and since most of us are technical people, we might build our own tools for tracking them. Have you already gone through that path? Some of our best friends have gone, wasting 80% taking data instead of taking decisions. Lots of places to look at, mainly silos of data you need to massage to get information out of them, and limited amount of time understand and manage your project.

During this talk, we will present some community managers typical questions and how tools OSS, like for example GrimoireLab, could be used to answer them, allowing the community to behave as data scientists extracting valuable information from within and be a data driven community.

These kind of tools represent a new ecosystem for “Open Development Analytics”, where communities can (and probably should) rely on open tools to ensure transparency on such important process like “measuring the community”.

Presenting the KDE SlimBook laptop and answering any questions the audience may have.

Please note this talk replaces "Assumptions made when porting to a modern display server" by Brandon Schaefer, who got sick with the flu.

Ceph is a highly available distributed software defined storage, providing object, key/value and file-system interfaces. Ceph Rados Gateway (Radosgw) provides HTTP REST API that is S3 and openstack swift compatible. This talk will cover cloud object storage concepts and how Ceph implementation of cloud object storage (Radosgw). This talk will also present the newest features and our plans for the future.

Presentation of the talks of the schedule of this year.