FOSDEM welcome and opening talk.

Welcome to FOSDEM 2019!

The FOSS community suffers deeply from a fundamental paradox: every day, there are more lines of freely licensed code than ever in history, but, every day, it also becomes slightly more difficult to operate productively using only Open Source and Free Software.

In one sense, we live in the paramount of success of FOSS: developers can easily find jobs writing mostly freely licensed software. Companies, charities, trade associations, and individual actors collaborate together on the same code bases in (relative) harmony. The entire Internet would cease to function without FOSS. Yet, the "last mile" of the most critical software that we rely on in our daily lives is usually proprietary.

We, the presenters of this talk, live as the canaries in the coalmine of proprietary software. We have spent our lives seeking to actively avoid proprietary software but both personally and professionally, we find ourselves making compromises. In this talk, we will report the results of our diligent efforts to use only FOSS in our daily work.

Ideally, it would be possible to live a software freedom lifestyle in the way a vegetarian lives a vegetarian lifestyle: minor inconveniences at some restaurants and stores, but generally most industrialized societies provide opportunity and resources to support that moral choice. Not so with proprietary software: often, the compromise is between "spend hours or days for a task that would take mere minutes with proprietary software". In other cases, important opportunities are simply not offered to those who chose software freedom.

The advent of network services, which mix server-side secret software, and proprietary Javascript or "Apps", are central to the decline in the ability to live a productive, convenient life in software freedom. However, few in our community focus on the implications of this and related problems, and few now even try to resist. We have tried to resist, and while we have succeeded occasionally, we have failed overall to live life in software freedom.

In this talk, we will report on where the resistance fails the most and why. Finally, we will make suggestions of where volunteer developers can most strategically focus their efforts to build a world where all can live in software freedom.

Opening the MySQL, MariaDB & Friends Devroom !

This talk will give an update on the journey towards upstream, production-ready support for RISC-V in LLVM, Clang, and related projects. It will detail the project's start, current status, and next steps with a special focus on the work for support for building 64-bit Linux binaries (hard-float ABI, TLS, PIC etc.

For this second year of retro talks at FOSDEM we have a wide range of topics covered, from hardware design to software preservation, and of course emulation, for many machines like the ZX Spectrum, C64 or Atari ST.

Since the schedule is tight for the devroom, we'll ask people to note their questions on an etherpad during talks and have speakers answer later on, with a recap of the answers being sent on the mailing list after the event.

Describe your API with OpenAPI Spec (what Swagger grew up to be) and open the door to beautiful, adaptable documentation and a world of other possibilities.

Open API Specification is a machine and human readable way to describe APIs. From these specs we can generate documentation, create libraries, and ensure that our users know exactly what to expect from our APIs. This talk shows you around OAS from the beginning, showing how to create the specs and recommending some tools to help the process. Once you have the spec, things get interesting and this talk will showcase some of the things that you can offer once your API is described in this way. This session is recommended for writers looking to become more API-savvy and API engineers wanting to make their APIs more useful to their users.

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

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

This talks overviews the available quantum computing paradigms and outlines the pratical possiblities of leveraging and exploring the promised power of quantum computing processors that developers have today.

Using WebAssembly, Mono can now run your C# and F# code in the web browser. You'll learn about Mono's WebAssembly backend and the AOT and interpreter engines that power it, and see its modern dotnet SDK based toolchain in action.

A presentation of VkRunner which is a tool to help test the compiler in your Vulkan driver using simple high-level scripts.

Perhaps the largest part of developing a modern graphics driver revolves around getting the compiler to generate the correct code. In order to achieve this, extensive testing is essential. For OpenGL we have Piglit and its convenient shader_runner script format. On Vulkan, writing the boilerplate needed to test a simple shader is a lot more work. This is where VkRunner steps in to implement all of the boilerplate once and provide a very high-level scripting language to make it easy to write a test. The scripts contain the required shaders, any data they need to run and simple commands to draw or compute and probe the results.

This talk will give an overview of the functionality of VkRunner, its current status and the plans for its future.

Welcome to and overview of the eighth year of the Legal and Policy Issues DevRoom

Mgmt is a next gen config management tool that takes a fresh look at existing automation problems. The tool has two main parts: the engine, and the language. This presentation will have a large number of demos of the language. The language is a minimalistic, functional, reactive DSL. It was designed to both constrain the user with safe types, and no core looping constructs, but also to empower the user to build powerful real-time distributed systems.

Mgmt is a next gen config management tool that takes a fresh look at existing automation problems. The tool has two main parts: the engine, and the language. This presentation will have a large number of demos of the language. The language is a minimalistic, functional, reactive DSL. It was designed to both constrain the user with safe types, and no core looping constructs, but also to empower the user to build powerful real-time distributed systems. We will present a number of traditional use cases that were historically quite difficult to setup and deploy, but which can now be expressed as simple, short snippets of code. Examples will include service discovery, auto-scaling, provisioning, state-machines, scheduling and more! Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

A number of blog posts on the subject are available: https://purpleidea.com/tags/mgmtconfig/ Attendees are encouraged to read some before the talk if they want a preview!

In 2019, we will relaunch the old ODF Adoption TC at OASIS as ODF Adoption Open Project, to allow a wider participation from ODF stakeholders. The program is to announce the new project in March, and convene for the first online meeting before Easter. An update about the program status at FOSDEM.

The eXpress Data Path (XDP) is a Linux kernel feature, that have gain a lot of traction over the last couple of years. This talk is focused on how other FOSS projects can leverage XDP. How we believe XDP should be seen as a software offload for the kernel network stack.

The motivation is to plant FOSS seeds for collaboration by describing that XDP offers of facilities and capabilities. But also explain that XDP is not the magic-bullet by framing the XDP design and what layer it operates at (e.g. no de-fragmentation) and what limits XDP impose when enabled (e.g. no jumbo-frames).

In the second part of this talk we will focus on AF_XDP and how it can be leveraged by the DPDK project. AF_XDP is a new socket type introduced in Linux 4.18, that allow the XDP driver hook to deliver raw frames into userspace. This offers new opportunities for e.g. integrating with DPDK via a Poll Mode Driver (PMD) for AF_XDP.

Is running a Windows guest any different from Linux from KVM's perspective? KVM can pretend being Hyper-V and this is actively used for running Windows guests. Following Hyper-V naming convention, individual features are named "enlightenments": some of them are already mature, some of them were just added to KVM and some are still waiting to be implemented. What are these features and how Windows guests use them? How is it different from Linux?

Attendees of the talk will get to know the current status and the ongoing work for Hyper-V emulation in KVM, how this impacts Windows guests. Some benchmarks won't be missing too. The talk is intended for virtualization development engineers as well as system administration running KVM in production. In the talk both the internals of Hyper-V emulation in KVM and practical advises on how to run Windows guests on KVM will be discussed.

PLEASE NOTE THAT THIS TALK HAS BEEN CANCELLED.

Online identities are the cornerstone on which data-based capitalism is built - so, Google, Facebook and other OTTs are trying to dominate them and close them into silos. The ID4me platform extends OpenID Connect to create an open and federated architecture that allows any number of providers to interoperate, and gives back control to users, and a role to community service providers.

In the last years, the Internet has been increasingly centralized into the hands of GAFAM and other over-the-top companies that built walled gardens in fields like messaging and social networks. More and more of these companies have user data monetization and targeted advertising as a core revenue stream; thus, tracking people across their Internet activities is necessary to their existence.

This is why they have also built closed identity systems that supply single-sign-on and very easy sign up for new websites and services, at the expense of privacy and user control. As managing hundreds of separate accounts is inconvenient and insecure, and as alternatives such as password managers are not easy enough for the average Internet user, clicking on “sign in with Google” or “sign in with Facebook” has become a very common choice.

We think that this is bad for the Internet in general, and thus we are creating a platform that allows anyone to provide identities, creating an open, public and federated single-sign-on and data management system. We are extending OpenID Connect just a bit, the bit that is necessary to break the silos and allow interoperability; and we are basing the system on the DNS, the widely available and already federated naming directory of the Internet.

The talk will explain how the system works and encourage participation and contributions.

A presentation about the next version of VLC, called 4.0.

This is a continuation of the talk from last year, to explain exactly what was indeed implemented in the VLC core codebase.

A presentation about the next version of VLC, called 4.0, codename Otto Chriek.

This is a continuation of the talk from last year, to explain exactly what was indeed implemented in the VLC core codebase.

It notably speak about the results of the VLC 3.0 release, and speak about the following changes for 4.0: - the media library, - the core clock changes, - the new playlist, - the VR support, - and the new interface for Linux and Windows, using Qt5/qml.

FreeBSD is 25 years old! Learn the history of FreeBSD, why its use is increasing, and why you should use and/or contribute to FreeBSD!

Localization at Mozilla happens in a tight loop between development and localizer involvement. We're going to show how this works on Firefox for Desktop, and how it works for our Android projects. We show how we get to multiple testable builds a day, and how we mitigate the bad parts.

Welcome to the Free Java DevRoom

This session will be the opening session of the Open Source Design devroom. We will have a short introduction to the Open Source Design collective, what we do, who we are.

We also welcome new comers to FOSDEM, user-centred design, or open source to introduce themselves, tell us a little bit about the work they do, and what they're looking to learn or find out.

It is a good opportunity to meet potential collaborators and make new friends. ☺️

Weaviate is an open source decentralized knowledge graph. During this talk, I will introduce the software Weaviate, present specific use cases, present Weaviate's architecture, and introduce one of the core features: the contextionary. More info about Weaviate: https://github.com/creativesoftwarefdn/weaviate

Go 1.12 is planned to be released in February 2019 and this talk covers what's coming up with it.

We'll talk about Go Modules, the proposals for Go 2, and all of the new things you might have missed.

This has been a staple talk of the Go devroom, opening the stage every year, and has always been a successful one.

The presenter has more than 10 years of experience in installing, configuring, designing, migrating Puppet infrastructures of any size and kind. This presentation is all about sharing experiences and knowledge on what has worked and what hasn't, ways to introduce automation and approaches to [Puppet] migrations. The final part is about what comes next and the role of Puppet and classic configuration management tools in the containers universe.

A presentation that outlines the kind of challenges that faces whoever has to automate the configuration and the management of an IT infrastructure. Understanding who has to implement and maintain the automation, what are the elements to cover, how their configurations change in the infrastructure, what are the priorities and the timings. Then deliver and implement an operative approach for the migration and maintenance. All this with a historical perspective which involves reasonings on the role of configuration management in current and future IT landscapes.
Topics are based on the presenter Puppet experience but focus on principles valid to any automation challenge.

Understanding FOSS licenses are indisputably an important part of the process for contracting for IT services ranging from software agreements, professional services to create or support software, and to cloud solutions.

It’s not uncommon to find carve outs in those agreements saying that “Some Third-Party Content may be provided to you under a separate license, such as the Apache License, Version 2.0, or other open source license.” What does that mean? Are there any surprising terms to be found in those “other open source licenses”.

This presentation will briefly review the terms of some of the less commonly discussed licenses approved by OSI as “open source.” What are some of the interesting properties of these less common licenses? And do we really want to keep agreeing to use them in our contracts?

There are 83 licenses listed as approved “Open source” licenses on the Open source initiatives website. Most of the time when developers, lawyers, and FOSS compliance experts talk about “open source” licenses the permissions and obligations of the nine licenses listed on OSI’s “popular licenses” list are front and center. Occasionally a few other licenses like the AGPL and the Creative Commons licenses are considered as well. But what about the other 70 licences? Do the generalizations and expectations many of us have based on the popular licenses hold up when we start to consider the other OSI approved licenses?

This presentation will argue that many the spoken and unspoken expectations of open source licenses do not generalize well when we consider the full list of licenses approved by OSI. This can be a challenge when IT policies and contractuals are written about “open source” licenses generally. Do organizations that are comfortable working with and using open source software and licenses really want to bound by all of the obligations in every free software license? Are the generalizations we make about open source licenses really true for every license? Do we need to be more careful in crafting policies and contracts then treating all open source licenses the same?

This presentation will review attributes found in the un-”popular licenses” that have been approved by OSI that differ from the unique and common attributes found in the popular licenses.

For example not all of them are classified as free by the Free Software Foundation and some appear to not be acceptable for inclusion in Debian. We will look at the public rationale for Debian and the Free Software Foundation refusing to include those licenses. We will also look at other unexpected properties of other licenses that may challenge many of our internal models for open source licenses.

We will also look at which licenses have the unusual attributes such as: * Choice of Venue Clauses * Choice of Law clauses * Unusual distribution clauses such as - requirements to secure assent to the agreements and licenses - Mandatory Public publication requirements for specified periods of time - Grant of third party beneficiary rights for recipients * Retaliation clauses with broad scopes (terminating all rights for unrelated litigation) * Licenses that have restrictions or contingent obligations that trigger on use * Exclusion of patent rights * Restrictions on selling copies of software

We will pay particular attention to licenses that impose obligations on individuals for merely using the software even if they don’t modify the software such as: * requirements distribution when software is used and the various ways use triggers: * distribution and to whom distribution is required under those circumstances. such as the several licenses that require sharing source code when you use it or let others use it. * Indemnification of authors of the source code

A talk about the history of the Atari ST/STE/TT/Falcon emulator "Hatari", and the difficulty of emulating these machines in a cycle-exact way. This talk is for everybody who is interested in emulation of old computers, no special previous knowledge is required.

• A short overview of the Atari ST and successor machines
• The history of the the Hatari emulator
• How to get started with using Hatari (explanation of disk images and firmware ROMs)
• Hardware tricks on the ST and why cycle-exact emulation is required here

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

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

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

"Don't expect patches to the core. It's just too complex for external developers." Nearly twenty years ago, that was the broadly-held opinion at MySQL AB. Now, with MariaDB, there are 174 contributors to the server alone and Monty isn't the top contributor by commits or even LoC. Clearly, some things have changed, but what are they and how much impact have they had? In this fast-paced session Zak Greant, MySQL's first community advocate, will walk through some of the critical changes over the years and share some of the best (and worst) practices.

In the early days of MySQL, we had the idea that people didn't contribute to the core because the code base was too difficult to get into. Perhaps this was correct at the time, perhaps not. Nearly twenty years later, the MariaDB project sees contributions from a wide range of contributors and to many different parts of the project - including the MariaDB server. Clearly, many things have changed in this time. In this session, I'll present some of the key macro and micro changes, and present conclusions about how they have come about.

For instance, if the server was the most difficult part of the MySQL/MariaDB code to contribute to, why are there so many more contributors and contributions now? Potential causes could include:

• the widespread adoption of MySQL and MariaDB
• the popularity and maturity of the projects
• the change in corporate control
• maturation of the broad Free Software/Open Source community
• improvements in collaborative development infrastructure
• better community management practices
• more senior project members or senior project members having more time to mentor contributors
• better incentives for contribution
• better contribution management processes
• the long time span has let people learn the code base better (as many contributors were or are MySQL/Oracle/MariaDB Corp. staff)

I'll support the talk with a written report and I'll share my research, including:

• analysis of commits and contributors over time
• maps of contributors journeys over time (eg. what did one have to do to get a patch into MySQL in ca. 2000 vs. MariaDB in 2018)
• a timeline of changes to key policies, contribution infrastructure, corporate involvement, etc.

The history of programmers trying to use programming languages for data files, configuration, or UI description files, is filled with horror stories. "WHY in the world did we choose Lua for our data files again?" was an interrogation I had not so far in the past, when I was working for a big game company. "HOW did we let this Grunt file grow more than 8000 js lines?" was a more recent one. Programming languages are NOT a good fit for data files. But there may be another way... Today, I want to talk about my favorite part of lisp languages: making your own languages when you need them. By that I don't mean making a big pile of utility functions or macros for the savvy lisper to drool upon, but actually taking the time to think about a file format, may it be completely static, and make it from scratch using s-expressions. Those parentheses may be good for something in the end...

Marionette is the library integrated in specific builds used for unit testing in Firefox. Using Python enables to automatize procedure or other stuff using the browser also in headless mode. Let's see how it is possible to simplify your daily job routine on internet like a pro.

Often there are tasks that are easily to automatize with scripting but this portal/website doesn't offer API. Develop a browser extension only for an internal usage can be an over engineering step but there is another way. Python is a powerful language and we can use it also to integrate in other services or to help a community. There will 2 real cases: how to export WordPress posts without having advanced backend permissions to reimport it later and how to automatize the reject of bad translation in the WordPress community based on terms.

Tooling has always been a focus for TypeScript and a large reason for its success. TypeScript code intelligence is available across many editors and even web-based tools, all provided by the same service TypeScript ships out-of-the-box with the compiler itself. This presentation gives a tour and history of how TypeScript is able to provide the same great experience to many different clients through the tsserver and tsserver protocol, as well as how it influenced and fits into newer efforts like the Language Server Protocol. I will show how it can be used to provide code intelligence features like jump-to-definition and find-references at cross-repository scale, using some of TypeScript’s newest features like declaration maps and combining it with lesser-known interesting features of the JavaScript package management tooling. At the end of this talk, the audience will know how TypeScript tooling works under the hood and how it can be combined with other tools in the ecosystem to make developers more productive. The goal is to inspire innovation in the TypeScript tooling ecosystem by showing what is possible and how.

Rigetti Computing manufactures programmable quantum computers. As a part of that, they have developed a number of new technologies: a programming language, compiler, simulator, runtime, language bindings, and execution environment. Together, these form Forest, their quantum software development kit. We discuss Rigetti's open source quantum ecosystem, and how we see it developing in the coming year.

Rigetti Computing manufactures quantum integrated circuits, and they become computers when the silicon is made programmable. Programming a quantum computer is fundamentally different than programming a classical one. The earliest quantum computers will run hybrid quantum/classical algorithms, marrying traditional software approaches with very non-traditional paradigms born out of quantum mechanics.

In this light, open source quantum software serves dual purposes. First, it makes the mathematical realities of quantum computing more accessible to non-experts, and second, it leverages the vast innovations made by countless open source software engineers around the world. Both of these serve to maximize the power of near-term quantum computers.

We discuss the fundamental nature of an open source quantum development ecosystem, starting with the quantum programming language Quil, and discuss how that's made into a practical tool through open source quantum software development kits. We discuss Rigetti's open source quantum ecosystem called Forest, and how we see it developing in the coming year.

Virtualization, including safe pass-through guest access to devices, is a well-known and mature technology on servers. With the increasing complexity and abilities of SoCs, virtualization is gaining importance on embedded systems, too. In this presentation, Geert will explore virtualization and device pass-through (VFIO) using QEMU and KVM on a Device Tree-based embedded ARM system, pursuing the holy grail of embedded developers: the ability to blink a connected LED. While seemingly too trivial and inapplicable, Geert will show how relevant such a contrived example is to more complex real-world uses of device pass-through. He will talk about the obstacles he encountered, and how they were overcome, enabling the use of device pass-through for real on-SoC devices using DMA. Finally, Geert will discuss when to use device pass-through, and when other virtualization techniques offer a better solution.

In this presentation, embedded developers will get a grasp of virtualization, and can expect a hands-on report of getting device pass-through working on DT-based systems, enabling them to accelerate implementing virtualization in their own projects and products. Understanding the differences between traditional PCI-based servers, and relatively new embedded systems with DT, will help software developers improve support for device pass-through, in both Linux and virtualization environments like QEMU/KVM. Hardware (SoC and board) designers will learn about the impact of their design decisions on virtualization, and what to take into account to allow efficient virtualization of hardware devices.

How do you bring order to this chaotic web frontend climate fueled by the ever-changing technologies driving it? We - a UX Designer and a Software Engineer - will introduce you to the concept of WebComponents, and how we can achieve order through evolving from Bootstrap to CSS grid based design system.

Target Audience: designers and engineers. our talk introduces the importance of collaboration and bringing designers and engineers together.

The Red Hat portfolio includes about 50 different products. There was a need for a design system as different patterns were build over and over again which led to inconsistency. The UXD goal is to bring consistent user experience to the entire Red Hat portfolio. This talk explains why it is important to have a unified look and feel. Patternfly is an open-source design system that helps our designers and engineers build user friendly products. As the frontend technologies are constantly evolving, this design system has to evolve with them. We would like to talk about the history and evolution of PatternFly - how it was created and how it tries to handle the continuous evolution of the frontend landscape. Perspectives from both design and engineering will be included.

I'll show how to quickly build a simple desktop app with Go+HTML5, that doesn't look like it's from the 90s, neither it feels bloated like Electron.

User interfaces have come a long way from punch cards and command line to post-WIMP era with touch screens and voice input. Modern UI is expected to be fast, responsive and smooth, with high-quality typefaces, rich images, animations, accessibility. HTML5 handles it all very well, and with GPU acceleration it has decent visual performance. Go may have stated itself as a language for writing services, but with Redux architecture GUI apps are not much different from request/response model. Having excellent performance, Go is a perfect fit for writing core app logic. The only thing that's missing is a link between HTML5 and Go, so that Go code could be called from the UI, and UI could be manipulated from Go.

HTML5 is often considered heavy because it requires a browser engine. We don't want to ship browser runtime with each and every app. One solution is to reuse the native OS runtime. Another is to use some pre-installed browser in the standalone app mode. Both end up with small, fast, self-contained binaries that are easy to build and to distribute.

I would like to briefly explain how each approach works, and how to choose one that fits better for your needs.

I'll introduce Webview1 and Lorca2 libraries and show how to build a quick desktop app in Go with either of those. I'll cover bootstrapping the new app, communication between Go and UI layer, debugging UI, building and packaging the app. I'll do the demonstration on Linux, but will show how to prepare the same app for Windows/MacOS.

The Linux community is slowly moving towards better quality trough automated testing to prevent regressions in mainline and stable trees. However, Linux is full of HW-specific code which makes validation of patches impossible for individual developers, which leads to regressions. In this talk, we will explain how we solved these issues by getting inspired by Linux's development model, and how we extend it to the development of our testsuite, CI infrastructure and bug handling.

After 2 years of activity, this led Linus Torvalds to say i915's quality has greatly improved compared to other graphic drivers.

Linux's development model has been described as being akin to a bazaar, where any developer can make changes to Linux as long as they strictly improve the state of Linux, without regressing any application that currently runs on it. This allows Linux users to update their kernels and benefit from the work of all developers, without having to fix anything in their applications when a new version comes. Unfortunately, it is impossible for developers to try their changes on all the different hardware and userspace combination being used in the wild.

Typically, a developer will mostly test the feature he/she is working on with the hardware at hand before submitting the patch for review. Once reviewed, the patch can land in a staging repository controlled by the maintainer of the subsystem the patch is changing. Validation of the staging tree is then performed ahead of sending these changes to Linus Torvalds (or one of his maintainers). Regressions caught at this point require to bisect the issue, which is time consuming and usually done by a separate team, which may become a bottleneck. Sometimes they let regressions through, hoping to be able to fix them during the -rc cycles.

To address this bottleneck, the developer should be responsible for validating the change completely. This leads to a virtuous cycle as not only developers can rework their patches until they do not break anything (saving the time of other people), but they also become more aware of the interaction their changes have on userspace, which improves their understanding of the driver which leads to better future patches.

To enable putting the full cost of integration on developers, validation needs to become 100% automated, have 100% code/HW coverage of the userspace usecases, and provide timely validation results to even the most time-pressured developers. To reach these really ambitious objectives, driver developers and validation engineers need to be considered as one team. The CI system developers need to provide a system capable of reaching the objectives, and driver developers need to develop a test suite capable of reaching the goal of having 100% code coverage of the whole driver on the CI system provided to them.

Finally, this increase in understanding of how validation is done allows developers to know if their patch series will be properly validated, which reduces the risk of letting regressions land in Linux.

The devil however lies in the details, so in this talk, we will explain how we are going from theory to practice, what is our current status and what we are doing to get closer to our ambitious goal! We will describe the current developer workflow and demonstrate how we empowered developers by providing timely testing as a transparent service to anyone sending patches to our mailing lists.

The talk presents a project that use pot containers to implement a CI/CD pipeline on FreeBSD. The presentation highlights the internal structure of the project, showing how jails and ZFS are used to efficiently implement a build pipeline.

Kodi v18 has been in development for over two and finally it is released. During this presentation we go through the most important parts that were added or changed and what this actually means for the future.

During past two years developers in and outside of the Kodi Team have been steadily refactoring and working on new features that will be included in Kodi v18. Although we initially thought about doing a RERO release it ended up being quite the opposite. In this presentation we will go through the most important parts that are actually included and why it took so long to come to a final release. Additionally we will briefly cover some parts that we already know will go into v19 at the moment we branched of the current v18 release.

Loop mounts let you mount a simple file as a device. But imagine having "FUSE for loop mounts". Linux Network Block Device (NBD) with the nbdkit server takes the concept of loop mounting to the next level, giving you a flexible, scriptable loop device, useful for end users, and for developers wanting to test anything involving a block device.

Loop mounts let you mount a simple file as a device. Network Block Device (NBD) with the nbdkit server takes this concept to the next level. You can mount compressed files. Turn multiple files into a partitioned device. Mount esoteric formats like VMDK. NBD can also be used for testing: You can create giant devices up to 2^63 bytes in RAM and find out how filesystems cope. Inject errors on demand into your block devices to test error detection and recovery. Add delays to make disks deliberately slow. I will also show you how to write useful block devices using 10 line shell scripts, and show some advanced live visualizations of how the kernel and filesystems use block devices.

The FLOSS movement is not just about convenience; our DNA includes a set of values that bring life to FLOSS. We’ve seen some of these values encoded in the infrastructure of the Internet and online life. We’ve also seen very troubling characteristics emerge online, where individuals and society face new and sometimes explosive risk. This talk explores how the FLOSS movement might reevaluate our values and seek to apply the lessons to our own projects and perhaps more broadly to online life as well.

Today FLOSS software is everywhere. In some ways the dream of 20 years ago has been realized. FLOSS software is the norm, GitHub is mainstream. The technology that dominates our era — the internet — is firmly based in FLOSS software, open standards, and interoperability. These are victories, and we should celebrate them. FLOSS was radical idea, and we proved its value.

However, Internet life is increasingly run by a handful of organizations. Many of these, like Facebook, google and amazon have FLOSS software at the core of they systems. However, the layers on top are not FLOSS and there is little openness in the systems they create and run. Today a common refrain is “the Internet is broken. What can we do?”

One part of the answer to this is to be found in FLOSS software. That’s because FLOSS is not just a matter of convenience, of grabbing a library somewhere because it’s quick and efficient. FLOSS is not something of the past. FLOSS is not something settled, and comfortable and run of the mill.

FLOSS is about freedom.  It’s about the choice of the individual to not accept what we are given, the freedom to branch off, to fork off and create something different. 
Floss software is not about wringing the very last cent of value out of a piece of software for the benefit of a small set of people.  FLOSS software is about creating value for everyone.
FLOSS software is about collaboration. 

We need all of these values in digital life today. We don’t have them, just as we didn’t have them in desktop computing in the windows era. We didn’t have them until FLOSSS made them real. Starting with developer tools and compilers and building to operating systems,systems, and then browsers and then all sorts of software. We need that journey in digital life as well.

It won’t be easy. Facebook and Google and Amazon and Alibaba are powerful monopolies just as Microsoft was in the previous era. It won’t be easy— there will be a period of building developer tool s and libraries before the FLOSS movement generates a raft of full fledged complex products. It may not be easy, but its worthwhile. its’ beyond worthwhile — its critical. And it can be wildly rewarding.

FLOSS advocates and developers can not solve all the problems of digital life. But we can play an important role, a critical role. The world needs technologists who show that a better way is possible. We show a better ways possible by building a better way. By building tools and libraries and products that give a meaningful choice. Some will protect privacy, others will be algorithms and data sets that are transparent and verifiable. Others you will dream up. or perhaps you are working on them now.

For many people today technology is becoming frightening. the world is looking for technologists who with values, and technologies who actually live by their values. The FLOSS world does this. We have licenses that we don’t change whenever it’s convenient or might bring us more money than fame. We live with them because we have decided as a community that our licenses reflect enduring values that are bigger than we are.

We need FLOSS communities and projects in an every larger variety of the tech world. Perhaps that means reaching outside our own comfort zones. Or perhaps it means expanding the circle to include colleagues in open data, AI and other new technologies. We should be examples, support examples, and demand that more and more of online life incorporate the values that draw us to FLOSS. And we build and support those people and projects that are doing so.

The story of building our enterprise Ethereum client documentation, successes and failures, things we tried, decisions we had to make...

At InnoGames we have to keep track of three collocations, ~30 racks with thousands of VMs to run games for over 200 million registered users. We have to manage our self hosted as well as various external services and preferably do so in a way that does not wake our oncall admin at 3am.

All our infrastructure is configured via a central configuration management database. We use that database to keep track of physical and virtual machines, network equipment and configuration, monitoring and much more. We have open sourced our configuration management database [0], as well as our tooling for managing KVM VMs [1]. What makes serveradmin unique is how easy it is to modify the database schema as well as its very easy to use and fast API.

This talk will - give you an overview over our infrastructure and custom tooling. - explain our approach to API driven infrastructure automation. - show you how to model your infrastructure in serveradmin. - demonstrate creation, deletion and live migration of KVM VMs.

[0] https://github.com/innogames/serveradmin [1] https://github.com/innogames/igvm

The National Development Council in Taiwan have asked the OSSII, a local LibreOffice service provider, to develop a solution that can directly generate ODF reports, while the servers in public administrations do not need to change a lot.

To adopt ODF and LibreOffice in Taiwan, a very important part, besides desktop applications, is to ask the reports generated from servers in all the public administrations to be in ODF format. Currently almost all reports are in Microsoft office format; some of them are even non-standard -- they can be opened by Microsoft Excel, but can not be converted by LibreOffice. Hence, the National Development Council asked the OSSII, a local LibreOffice service provider, to develop a solution that can directly generate ODF reports, while the server side do not need to change a lot. This talk gives a simple introduction of how this solution works.

The CERN OHL is a copyleft open hardware licence which was launched in March 2011. It has undergone point releases 1.1 and 1.2 and since then, but feedback from user communities, particularly those working with microprocessor cores and FPGAs has made us reconsider some of the fundamental assumptions made when the licence was first drafted. We have shamelessly taken ideas from other licences as well as introducing some new approaches, driven by the needs of users. This session introduces our new draft of version 2.0, which aims to make v2.0 more flexible than any previous version, while increasing clarity of drafting.

Full Description} Hardware is more complex than software from an intellectual property perspective, and this makes developing an open hardware licence, especially a copyleft/reciprocal open hardware licence, particularly challenging. The CERN OHL has been designed to work with as wide a range of hardware as possible, from artistic works, through mechanical devised, to circuit board layouts and, more particularly to software, microprocessor cores and even FPGAs and ASICs. At the same time, we recognise that hardware is a different domain from software, and that it is a mistake to assume that lessons learned in the software domain can automatically be applied to open hardware.

We have listened to the concerns of many users and potential users of the CERN OHL, and have produced a radical redraft of the licence which aims to:

be concise and clear; be appropriate for a wide range of different use cases in fields of use (such as microprocessor cores, FPGAs and ASICs); be appropriate for a wide range of users, from not-for-profits through to commercial organisations; be compatible, so far as possible with other licences like GPLv3 and TAPR; be easy to use; discourage licence proliferation; encourage compliance as the main outcome of enforcement; maximise the availability of open hardware designs to the public; maintain the same spirit as the previous versions of the CERN OHL; allow for strong- and weak-reciprocal licensing models, as well as permissive models.

The new version 2, in its three variants - strong, weak and permissive, is the culmination of significant drafting effort with the input of a wide range of users and potential users of open hardware licensing.

This talk introduces some of the key concepts in the CERN-OHLv2, explains its evolution from previous versions, and aims to explain how it can best be applied to a number of different types of hardware.

Internet has become an integral part of our lives and everything we do online leaves a trail of data. This data is being collected, analyzed, sold and aggregated to cast profiles about us by companies across the globe.

In the physical world, if a stranger was to follow you everywhere you go, keep a log of who you talk to and meet with, read your mails and then share all this information with others, wouldn’t you be concerned? But somehow in the digital world we do not seem to worry too much about the same scenarios.

One of the main reasons for this is lack of awareness about how most Internet companies are making money these days. In fact, as a consequence of the business model of brokering personal data, a surveillance capitalism emerges.

With the advent of SaaS, website and app owners usually outsource functionality like analytics, recommendations, A/B tests to be managed by third parties, with legitimate business purposes.

While these use-cases might seem legit, the way data is collected to solve the legit use-cases are bound to harm the user’s privacy. You end up sharing sensitive user data with the companies you may have never heard of. They can not only link the webpages you visit but also have the ability to de-anonymize you by knowing your name, email, address, passport number etc.

Once this information leaves your machine, it is out of your control. From it, a detailed profile about you is created, which is then available to a whole bunch of parties, which may or may not live to any ethical standards. With accurate enough profiles, companies and data brokers can simulate the behaviors and decision making of the world's population. They don't even need everyone's interactions because they can infer the whole population behavior from just a few examples of each cluster.

This is why privacy is everyone’s concern so we need to raise awareness: - The general public needs to know how every move that they make in the online world is being tracked, shared and used. - Developers need to consider how their users and customers' data deserves to be treated with respect and care, not sold unknowingly to faceless companies.

But how do you transmit this complex reality to the broader audience outside our community? What data is being shared unconsciously? Who are these data collectors? What is the impact of our blocking mechanisms as users?

This is precisely the problem both Local Sheriff and Trackula tackle.

In this joint talk, we will showcase how two groups of people independently built Browser Extensions to answer these questions.

• Local Sheriff - informs the user about which PII is shared, and with which companies?
• Trackula  - from a less technical perspective and through a more visual UX focuses on raising awareness to non technical users.

More details about the tools can be found:

1.  Local Sheriff - https://github.com/cliqz-oss/local-sheriff
2.  Trackula – https://trackula.org/

Presentation of open source projects made at or used by Silicium, a french non-profit organization for the preservation of videogame and computer heritage.

At Silicium, we have a large collection of old computers and videogames, that we periodically present to the public. But machines break down, especially media and drives, so we like to use mass storage emulators and have tested quite a few: we will present the open source ones that we like and use.

Moreover some of our members have retrocomputing open source projects of their own, such as FPGA-based emulators of old gaming consoles. We will present their works and the development techniques they use, notably the MiSTer FPGA platform and coverification with Verilator.

Note that this replaces "Emulation revisited - narrowing the gap between software and hardware" by Gregory Estrade who is no longer able to attend the event, but will include parts of it.

Designing and operating high-performance, efficient, manageable and reliable MySQL replication deployments requires knowledge of the intricacies of the underlying technologies. MySQL Replication is no exception to this rule, even if it is becoming simpler to manage and operate by every release.

This session will provide insights on the main areas that affect the performance of Asynchronous Replication and Group Replication, and how to configure them to make the most out of the underlying computing system. We will also demonstrate the practical improvements that can be seen by going through various benchmarks. You will then understand when and how it would apply to your usage, allowing you to provide a better MySQL database service. Join us for an interesting dive into the always exciting world of MySQL Replication performance.

Gephi is a popular network analysis open source software written in Java. This talk about its future is a joint effort by the Gephi dev team and Javascript experts to explore the issues and opportunities of web technologies for large-scale network analysis and visualization.

Gephi relies on the Swing library for the general user interface plus an OpenGL insert for network visualization. This choice made more than 10 years ago was one of the very few options available for a multiplatform software able to harness GPU power for displaying millions of nodes and edges. Despite a number of issues, the situation was considered relatively satisfying.

However two long-term trends force the Gephi dev team to reconsider its future: computer infrastructures are moving away from true multiplatform software to web-based interfaces, and Java is moving away from user interface development to server-side computation. Most if not all UX developers agree that web technologies are better supporting modern UX design than the Java ecosystem. However the specific use of OpenGL puts Gephi is a special situation. We know from user surveys that scaling up your network is key to most users. No Gephi user has only small networks, and many of them has tried to analyze networks with hundred thousands nodes or more. This use case is far from usual in the world of web technologies. Is WebGL up to the task of visualizing such amount of objects?

We used existing Javascript libraries to build a stack comparable to the basic features of Gephi. Graphology was used as a Javascript equivalent of Gephi's GraphStore library, and a tweaked version of Sigma JS WebGL renderer was used as display engine. We used this prototype to benchmark the performance of web technologies for rendering large graphs in OpenGL.

In parallel we explored the possibility to keep the project in the Java world but stop relying on the JOGL library that is at risk of being less and less maintained. In this mind we developed a new OpenGL visualisation engine prototype, with a better code base and better performance than current implementation.

In this talk we will showcase both the Javascript proof-of-concept and the new Java prototype. We will present state of our reflections and the results of our benchmarks. Of course technological choices are not only (and even not primarily) a question of performance, and we will take the time to discuss the various issues and limits we met in this exercise of prospective technological exploration. we will conclude with a broader reflection on how Gephi as an open source project tries to adapt to global technological changes.

We expect this talk to be useful to Java and/or Javascript developers/engineers dealing with graphs.

Eduardo Ramos Ibáñez is lead developer of Gephi Mathieu Jacomy is co-author of Gephi Alexis Jacomy is co-author of the Sigma JS library Guillaume Plique is author of Graphology and co-author of Sigma JS

Interactive Fiction, or "Choose Your Own Adventures" games, have been reinvigorated by new, friendly tools such as Twine. Twine and its scripting language Harlowe are a type of Templating Language, where static presentation content dominates, but is modified by small snippets of embedded code. Thus, Harlowe is in the same family of templating languages such as PHP, M4, or front-end web application libraries. I examine the characteristics of truly minimal templating languages intended for non-programmers and demonstrate a toy templating language built with Scheme.

From the point of view of language design and implementation, scripting languages for interactive fiction or visual novels -- such as Harlowe, SugarCube, or Ren'Py -- are interesting in their pragmatism. They hide complexity from the programmer and try to put focus on generating story content. While paradigms such as Model-View-Controller or Model-View-ViewModel tend to crop up in general-purpose programming languages to help manage front-end complexity, these languages mix code and content much like how PHP or HTML+JavaScript was used a decade ago. But by keeping syntax simple, the MVC or MVVM separation of concerns is not necessary.

To keep things intuitive for the non-programmer, they make some interesting decisions about readers, interaction models, procedure definitions, and scoping. These decisions are examined and contrasted with Scheme's standard programming paradigm.

Cilium is on open source project which provides networking, security and load balancing for containers by using eBPF and XDP technologies in the Linux kernel. It provides eBPF and XDP features to CRI-O, Docker and Kubernetes. This talk will present an overview on Cilium, explain the concepts behind it and then provide the project update, as it reached the 1.0 milestone last year.

Bio: Michal Rostecki is a Software Engineer working at SUSE. He's contributing to Cilium on daily basis, sometimes to Kubernetes and several projects related to containers and networking. He used to be a core reviewer for OpenStack Kolla project.

Rumble in the Java Jungle

OracleJDK, OpenJDK, AdoptOpenJDK, OpenJ9, Zulu, IcedTea, Liberica, SapMachine, GraalVM, SubstrateVM. 8, 9, 10, 11, 12, 18.3, 18.9, short-term, mid-term, long-term support release, security updates. GPLv2, Classpath Exception, Oracle Binary Code License, Technology Network License Agreement. Field of use restriction, private and commercial use, reference implementation, substantially derived, TCK/JCK, Oracle Contribution Agreement, OpenJDK Community TCK License Agreement (OCTLA), Java Community Process (JCP), Java Specification Request (JSR), Java Enhancement Proposal (JEP), Preview Features, Incubator Modules, Java (TM), Java SE compatibility, OpenJDK trademark notice.

Confused? Come and hear from Java and OpenJDK veteran Volker Simonis how the Java world has been radically turned inside out in the last year and how this impacts you as a Java user or developer. After the talk you'll have a clear understanding what's going on in the Java ecosystem and you'll be ready to plan your or your companies future Java strategy.

Presentation of the organization Exodus Privacy and its study of the respect of privacy by Android applications, via a platform performing static analyses of APK files (in order to identify trackers embedded in Android applications)

Exodus Privacy is a French non profit organization founded in 2017 and animated by hacktivists. We developed an open-source platform (called εxodus) in order to analyze Android applications from the Google Play Store and their respect of privacy, through the static analysis of APK files. This platform provides the public with reports presenting, among other things, trackers embedded in Android applications.

During this talk, we will present in details how we are analyzing Android applications on the εxodus platform and its results, as well as the impact on our privacy that represent trackers which have invaded our smartphones.

The talk tells the story of how the Debian GNU/Linux port for the RISC-V architecture came to life and describes the steps and challenges involved in adding support for a completely new architecture to one of the major Linux distributions. It provides an overview of the current state of the port and gives an outlook on further developments.

What's hot right now in the proposal for Ada 2020 is increased support of safe parallelism. However, the support for sequential programming in Ada 2012 is absolutely great and probably underestimated.

This presentation will demonstrate lessons learned from making an Ada binding to the Wayland Client API: how to leverage nested subprograms, pragma Unmodified, subpools, Gnatcheck and GPS to provide a flexible/enjoyable way of working and at the same time maximize compile-time error checking when developing sequential algorithms.

HTTP/3 is the next coming HTTP version. This time TCP is replaced by the new transport protocol QUIC and things are different yet again!

HTTP/3 is the next coming HTTP version.

This time TCP is replaced by the new transport protocol QUIC and things are different yet again! This is a presentation about HTTP/3 and QUIC with a following Q&A about everything HTTP. Join us at Goto 10.

HTTP/3 is the designated name for the coming next version of the protocol that is currently under development within the QUIC working group in the IETF.

HTTP/3 is designed to improve in areas where HTTP/2 still has some shortcomings, primarily by changing the transport layer. HTTP/3 is the first major protocol to step away from TCP and instead it uses QUIC. Daniel Stenberg does a presentation about HTTP/3 and QUIC. Why the new protocols are deemed necessary, how they work, how they change how things are sent over the network and what some of the coming deployment challenges will be.

In a world littered with containers, microservices, and virtual networks, the need for a reverse-proxy increases. I'll introduce you to the world of reverse-proxies by writing one -- live, and from scratch. Step by step, we'll discover the responsibilities of a reverse-proxy and how to fulfill them.

How Kubernetes SIG Docs changed our stack, our git workflow, and the world.

One year ago, the Kubernetes documentation group (SIG Docs) received a request: could we host a Chinese localization of the docs? One year later, the answer is yes--we host Chinese docs, as well as several other languages, with more localizations in the works. This talk is about what happened with Kubernetes SIG Docs in the course of one year: the easy part (changing our site stack from Jekyll to Hugo), the difficult part (changing our git workflow), and the most challenging part (opening ourselves to internationalization). I'll briefly discuss the technical hazards we encountered (swapping Markdown parsers, Black Friday bugs), what worked well versus what didn't, and what we recommend for others looking to internationalize midstream.

Is there a single right way to enforce a code of conduct, community guidelines, or whatever you call the systems you have to help maintain a good community? This is a peek into how the Debian Anti-Harassment (AH) team functions, a few (anonymized) examples of issues handled, and the philosophy behind helping the Debian community to be a welcoming place for all contributors.

The Debian code of conduct (https://www.debian.org/code_of_conduct), mailing list code of conduct, Debian Community Guidelines, DebConf code of conduct, and even the Diversity Statement are tools used for the goal of building a welcoming and inclusive community for Debian.

As much of Debian's work is carried out in the open, so too are many of its problems, which can be visible on social media, in the blog aggregation site Planet Debian, and on public mailing lists. Inappropriate behaviors, harsh communications, and general poor decision making occur on a fairly regular basis. When problems arise within the project, they are typically escalated to either the Anti-harassment team or the Debian Project Leader (DPL). The Anti-harassment team (AH) tackles these problems on a fortnightly basis, making recommendations and directly contacting those involved in disputes or questionable practices.

Past, present, and the future of LibreOffice's Personalization dialog.

LibreOffice has had the ability to use Mozilla Themes (Personas) for some time (Tools > Options > Personalization); but it kept breaking all the time, and never had an acceptable UX. Also tons of errors/warnings, and very slow search and apply processes almost brought it to the point of being killed for good. But I couldn’t let it die, started looking into the related code and the bug reports. Now it has a better UX/UI, and got most annoying bugs/crashers fixed, and is much faster.

I will try to present a summary about the journey so far, and the plans for the future.

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

It will be fairly high-level and is targeted at both application developers and anyone interested in cross-platform multimedia.

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

Whether WebRTC, RTP, RTSP, SRT or RTMP, decoding or encoding, streaming or recording, we have it all!

Join us to find out what's new and improved!

VR took off for the consumer with the release of Oculus consumer hardware. But the hardware lacked open source drivers and Linux support in general. The OpenHMD project was created to solve this issue, and as it so happen it was funded by two former Chalmers students.

The consumer VR space has now grown from a crazy inventor in a garage into a large industry. But this growth has its down sides, multiple companies have their own APIs competing. Luckily these companies have agreed to work on a single API under the Khronos umbrella.

In this talk, Jakob will cover Khronos' OpenXR standard, give an overview about the current state of open source VR and what lies ahead.

Jakob works for Collabora with graphics and virtual reality. He has worked with Linux graphics since 2006, starting with Tungsten Graphics and moving into VMware. In 2013 he along with a friend started the OpenHMD project to make open source drivers for VR and AR hardware.

How many times did you need to start a virtual machine and either provide it with a directory on the host or use some file-sharing service (e.g., dropbox) or your email, just to copy a resource that resides within the virtual disk? In this session, Arik presents the upcoming integration between the muCommander file-manager and libguestfs. This produces an alternative to that complex process by enabling to browse/copy-from/copy-to various virtual disk formats directly using a user-friendly interface. Come to see the planned functionality and hear about the technical complexity of this integration.

muCommander is an open source cross-platform file manager that supports a variety of file formats (e.g., zip, tar) and file protocols (e.g., sftp, smb). These days muCommander is extended with a pluggable framework to ease the process of supporting more file formats and protocols.

This session focuses on a specific plugin for virtual disks. The plugin wraps the libguestfs library that provides an API for accessing and modifying various formats of virtual disks, such as vmdk and qcow. Libguestfs is a powerful library that is used by a variety of tools, e.g., the conversion utility virt-v2v. However, libguestfs lacks a user-friendly interface for those who wish to inspect and modify virtual disks as ordinary archive files. The plugin for muCommander aims to provide that via a dual-pane graphical interface.

The on-going development of this plugin exposes some of the complexity of integrating virtual disks, and libguestfs in particular, into a file-manager. For instance, unlike ordinary archive files, the operating system needs to be inspected in order to produce the tree structure of the file system(s). As another example, muCommander uses a stream based approach to copying files while libguestfs assumes local files or standard input/output. This session would cover not only the functional side of the integration, that will be demonstrated with images that resides on oVirt's storage domains, but also interesting sides of its implementation.

The accessibility of digital technologies in the European Union (EU) varies from country to country, due, in part, to differences in accessibility-related legislation. In October 2016, the European Parliament accepted a directive on the accessibility of websites and mobile applications provided by public sector bodies (Directive (EU) 2016/2102). New public sector websites in the EU will need to conform by 23 September 2019, all public sector websites will need to conform by 23 September 2020, and all public sector mobile apps will need to conform by 23 June 2021. The directive references standard EN 301 549, which has been updated to reflect the requirements in the Web Content Accessibility Guidelines (WCAG) 2.1. This new legal situation will create a greater demand for accessibility-related training and training resources for public sector bodies. The EU-funded project MOOCAP (MOOC Accessibility Partnership, https://moocap.gpii.eu/, September 2014 - August 2017) created 11 free online courses about various aspects of digital accessibility. Four of these courses ran as MOOCs (massive open online courses) on platforms such as FutureLearn and edX. The resources from these courses are freely available as Open Educational Resources (OERs) under the Creative Commons Attribution 4.0 International licence (CC-BY 4.0). This licence allows anyone to share, adapt and redistribute the content of the OERs, provided that they correctly attribute the MOOCAP partner (or partners) who created the resources. This presentation will briefly present the MOOCAP project, the courses it created (especially those that are still available) and the Open Educational Resources it made available.

In the game development world, games are built in layers, and it's common to have different languages for the different layers. C/C++ is a common choice for the engine layer, while C# is a popular choice for the scripting layer - the one that gameplay is implemented with, and the one available for users to mod their games with. There's multiple engines built on C# (Unity and Monogame come to mind).

When I started implementing my own runtime-moddable game with Unity, I realized how awkward C# is for scripting, and how there just might be a better language for this. In this talk we'll look at what a game scripting language ideally needs and does, why C# is not quite the best of fits, and why Typescript is - when it targets the .NET runtime!

At the end, you'll hopefully have a better understanding of how languages fit in game development and what (great!) tooling Typescript has for introspection and compiling.

Network traffic monitoring is traditionally based on packet analysis. While this approach still makes sense in many contexts, it is unable to provide detailed visibility when containers or virtual systems are used. This talk describes how the advent of eBPF enables the creation of monitor rich applications that can provide both network and application monitoring information to provide detailed information for both monitoring and troubleshooting. It shows how eBPF has been used in ntopng, an opensource monitoring application, and what are the challenges and pitfalls when integrating packets with system monitoring events.

This talk describes how packet monitoring and system-based event monitoring work and how they could be merged together to provide increased visibility. From the network administrator perspective the advantage is that monitoring does not stop at network level but it can also identify the application/username that has generated traffic. From a security standpoint this enables to identify suspicious network traffic and bind it to applications, for network administrators it allows faulty applications misbehaving users to be identified and tracked. System visibility is yet another layer of observability on top of traditional packet traffic monitoring and deep-packet-inspection.

An introduction to the simplicity of Tcl, some use cases, and examples of tweaking-and-extending.

Un-split brain (aka Move Back in Time) MySQL. This brings to light some of our recent work on disaster mitigation at @github.

Please note that this talk replace Jean-François Gagné's talk entitled "The consequences of sync_binlog != 1" as he wasn't able to join us in Brussels.

We're all convinced that automated tests are a good idea. For some applications (e.g. grep, awk, cc, ...) this is very straightforward. Others are a lot harder to test, for example firewalls. Typically testing firewalls takes two to three hosts. One to send traffic, the firewall test host and one to receive traffic. This makes automated test orchestration complex and brittle. This in turn means that tests either don't get written, are difficult to write and/or suffer random failures unrelated to issues in the firewall itself. Virtualisation has made this all somewhat easier, but it's still fiddly and difficult to make robust. It's also slow.

The new FreeBSD network stack virtualisation lets us build on the existing jails system to build test setups, execute tests and clean up in mere seconds, without any requirement for additional hardware, or even hardware virtualisation support.

FreeBSD 12 will ship with network stack virtualisation (known as VIMAGE or vnet). This is an important feature for many applications, one of which is automated network stack and firewall testing. As of FreeBSD 12 PF fully support VIMAGE, allowing users to configure a firewall for each jail.

This talk will introduce VIMAGE and show how it can be used to easily write firewall tests. If there's time a few interesting bugs and their test cases will also be discussed.

Quantum computing pioneer D-Wave Systems has led the development of quantum hardware and software over the past two decades. And the company has always taken a slightly different approach. Learn how at each step along the quantum computing journey, the company’s pragmatic decisions have brought quantum computing to market. From the development of the only commercially-available quantum computer to the recent release of the first Quantum Application Environment, D-Wave has long been at the forefront of bringing practical quantum computing to customers. This approach has helped customers and users develop over 100 early applications with real-world implications in industries spanning healthcare, defense, and automotive.

Alexander Condello, Ocean stack developer, gives insight into the company’s growth, beginning with years of research and the development of the first quantum computer – a 28-qubit machine built in 2007. Ten years later, D-Wave would realize Dr. Richard Feynman’s original vision of a quantum simulator, proving that its quantum computers could be used to simulate quantum systems at a large scale. This year, the company launched Leap, the first real-time Quantum Application Environment that provides immediate access to a live quantum system. The Leap environment hosts a robust online community, learning demos, resources and software tools for developers to start writing and running code, today.

From initial steps in hardware design to opening access through the quantum cloud, Alex discusses the technology and research that made this evolution possible, and what we can expect from the next era of quantum applications.

Project Loom’s mission is to make it easier to write, debug, profile and maintain concurrent applications under heavy load. Threads are a natural and convenient concurrency construct which is being supplanted by less convenient abstractions because their implementation as OS kernel threads is insufficient for meeting performance demands and wasteful in computing resources. Project Loom will introduce fibers as lightweight, efficient threads managed by the Java Virtual Machine, that let developers use the same simple abstraction but with significantly better performance and lower footprint. Fibers are implemented in the JDK libraries on top of scoped, stackful delimited continuations in the JVM. This session will present the current status and challenges of the project -- both of implementation and design -- one year in.

Minitel network stopped 6 years ago, but Minitel server software and hardware still exists and allow to re-discover how the whole system was working and how minitel users were interacting with this pre-internet media. Let's make COMPUTEL, an Apple II based Minitel BBS run again... more than 30 years after its shutdown...

An in-depth look at how caching works in ZFS, specifically the Adaptive Replacement Cache (ARC) algorithm. Assumes no prior knowledge of ZFS or operating system internals.

ZFS does not use the standard buffer cache provided by the operating system, but instead uses the more advanced "Adaptive Replacement Cache" (ARC).

• What is a cache
• How most caches work (LRU)
• Pros
• Cons
• What makes the ARC different?
• Recently Used
• Frequently Used
• Ghost Lists
• What makes the ARC Adaptive?
• Access Patterns (How the ARC adjusts over time)
• Compressed ARC
• Advantages over compressed memory or swapcache
• Tuning for...
• File Server
• iSCSI Target
• Database
• Hypervisor

Nowadays real-time Messaging Systems has become widely used, covering a variety of use-cases, from log aggregation to real-time Stream Processing (in combination with Big Data Processing Frameworks). In this talk we'll introduce how to use Apache Kafka (the most used Message Brocker) in combination with Neo4j through the Neo4j-Streams project, demonstrating via simple use-cases how you can leverage the information driven by the Change Data Capture Module and how to add Neo4j in your streaming flow by using the Sink module.

Nowadays real-time Messaging Systems has become widely used, covering a variety of use-cases, from log aggregation to real-time Stream Processing (in combination with Big Data Processing Frameworks). In this talk we'll introduce how to use Apache Kafka (the most used Message Brocker) in combination with Neo4j through the Neo4j-Streams project, demonstrating via simple use-cases how you can leverage the information driven by the Change Data Capture Module and how to add Neo4j in your streaming flow by using the Sink module.

This talk covers topics such as:

• Theory of CI testing, where it can help and where not.
• Insights about your repository (Version Control Systems, VCS).
• Strategy (what to test, level of testing and when).
• Human/community aspects and challenges (Open Source Software, OSS).
• Workflows (Make your devs happy).
• Security.
• Examples of production setups.

This talk is slightly opinionated and based on experience gathered through various open source communities and companies.

Javascript has conquered the world - developers can use it in the browser, on the server, to write mobile apps, on the desktop with Electron, and even to create serverless services. Like the language or not, the truth is JS developers have built an incredible ecosystem with libraries and tools to do almost anything. During the talk I'll show how to bring the power of F# - the functional paradigm, static typing with type inference, pattern matching, and more modern language features - to this huge and rich JS world using Fable - F# to JS compiler. Fable doesn't add any runtime overhead and generates clean JS code in conformance with new ES6 patterns, like modules or iterables, making it compatible with modern development tools, including Github Electron or React Native to let you develop not only web, but also cross platform desktop and mobile apps. I'll demonstrate how to create different types of JS applications using F# - from React-based frontend application, through mobile app using React Native to serverless services.

With over 50 Public cloudbased on OpenStack, distributing workloads closer to customers is now a reality. Expect to learn how to leverage CI/CD to build multicloud Kubernetes clusters across several OpenStack Public Clouds.

We’ll start by presenting the benefits of multicloud and how Kubernetes and OpenStack fit in that strategy.

Multicloud architecture

Then we’ll explain the setup of a geo-distributed Kubernetes environment and this translates in OpenStack terms.

Cloud agnostic tools

An important part of multicloud is to have adapted tooling, so we’ll compare several tools to manage OpenStack resources (heat, ansible, terraform, …) and to install Kubernetes (kops, kubespray, kubeadm, …) in a cloud agnostic way.

Demo

We’ll put it all to the test with a live demo with a CI/CD application deployment across the globe.

Wrap up

Finally we’ll wrap it up with lessons learned and challenges of multicloud.

Data retrieval team at source{d} process lot of data from git repositories. Most of the key components in our workflow like engine, gitbase, mysql-server are implemented in Go. This talk will go through the story how we embedded "pilosa" (distributed bitmap index) in our SQL frontend for git repositories. - Why we decided to use bitmaps as indexes - How we got to the point where we are (we have embedded pilosa's server implementation inside mysql server implementation) - What problems we came across and how we solved them.

What kind of world do we want to see blockchain make? Upsides like increased transparency, distributed control and the elimination of duplicative administrative work are appealing, but where are the potential downsides? We no longer live in a world where we can put off a conversation about the social impact of our work. Old industries used to call negative effects of their work "externalities" and it would sometimes take decades to discover the negative social effects and environmental destruction that had been wreaked by a new technological process.

What kind of world do we want to see blockchain make? Upsides like increased transparency, distributed control and the elimination of duplicative administrative work are appealing, but where are the potential downsides? We no longer live in a world where we can put off a conversation about the social impact of our work. Old industries used to call negative effects of their work "externalities" and it would sometimes take decades to discover the negative social effects and environmental destruction that had been wreaked by a new technological process.

Software is collaborative and fast which means early technical decisions have a huge impact on the way we grow. Is the heavy amount of computing power required for bitcoin widening the global wealth gap in a way that best resembles a fictional dystopia? Is the decentralization promised only available to certain kinds of players because of certification gate-keeping or network effects that rely on huge amounts of existing capital?

Given the power and ubiquity of software, nothing is truly "external" to our work. Once we identify the ways that blockchain could potentially be used to build a nightmarish dystopia, what do we do? How can we ensure that the power and potential to improve lives is as evenly distributed as possible?

Uniformisation at the European level of data protection legislation brought on the table a lot of diversity in implementation from the private sector. Before the GDPR, member states had a specific national approach on how to interpret the previous Data protection directive 95/46/EC. Also, lots of actors came in the spotlight: the National Supervisory Authority, different public and private entities coming from all sectors of economy. The OSS community found itself driven in this ride and even with the best intentions nobody was able to find a complete, personalized guide to implement this new ruling that in theory is so welcomed. This talk is about pointing out how the Open source ecosystem is tangential with the GDPR data protection principles. Also, it will show how are the data protection rights and responsibilities shared between the community participants and the community's infrastructure providers.

The OSS field has as core value the concept of community, which helps a project evolve and make a difference in the software world. Not surprisingly a lot of the OSS projects are around the notions of privacy, anonymity and data protection, as they reflect in general a need that the people forming OSS communities have: to keep their personal data protected and avoid monopoly of that by proprietary software. The GDPR came as an effective tool to raise awareness about the importance of personal data and brought on the table specific principles, rights, obligations, along with a lot of improvements to be made in the current status quo. This talk will analyse how the provisions of the GDPR are tangential with the OSS ecosystem. It will point out how the principles of the GDPR are connected to the OSS world, how we could analyse the model of data controller / data processor in the context of the OSS participants / infrastructure providers. Also, it will point out how the data protection rights are enforced by the OSS model, by analyzing some of the technologies that have risen from this ecosystem: wikis and zero-knowledge collaborative software.

How do you design a user experience to guide both grassroot contributors as well as the advanced data researchers? That's what we were trying to solve in the past year for OONI Probe, the internet censorship measurement tool which enables thousands of activists worldwide to measure their network and automatically report potential anomalies of censorship. As part of the Tor Project, OONI Probe is vital to in helping the Internet Freedom movement, as all data gathered is Freely accessible as Open Data.

During the talk we will go through the redesigned OONI Probe 2.0 for Mobile and Desktop and explain the new design system and how we hope to design an experience which enables both advanced and beginners to OONI and measuring internet censorship.

Apache Camel is a free software integration framework from the Apache Software Foundation. This meetup is for anyone wishing to meet and discuss Apache Camel development, share experiences and meet in meat space other folk in the Apache Camel community.

Apache Camel website

Apache Camel has been around and its used quite widely for in all sorts of software integration projects. We recently kicked of a number of initiatives in the Camel community around the next version - Camel 3, cloud native Camel - Camel-K and building the new website. Let's meet and discuss this initiatives or just talk and exchange ideas around Camel. Anyone wishing to share can present on any topic relating to Apache Camel, though please be mindful of the time we have one hour in this session and would like that everyone would have the chance to participate.

The rise of cloud computing in the 2010’s accelerated a process that had been going on since the dot-com boom: the centralization of the internet. In February 2010, Eben Moglen predicted the wide-scale data-mining brought about by the centralization of our network infrastructure and launched the FreedomBox project. In the eight years since, FreedomBox has become a device that can decentralize the web one box at a time. Join this session to learn about FreedomBox’s approach to decentralization and the importance of three elements of its design: hardware neutrality, software freedom, and user interface.

In this 15-minute session, I will lecture for the full 15 minutes. I will discuss the FreedomBox project, the role of hardware neutrality in the FreedomBox project, and the role of user interface in the FreedomBox project.

FreedomBox is an immensely flexible and secure private server system that builds freedom into the internet by empowering regular people to host their own internet services, like encrypted messengers, a VoIP server, websites, VPN, a metasearch engine, and much more. To that end, it couples a free software system with always-on, inexpensive, and power-efficient hardware about the size of a pocket dictionary. The hardware is a single-board computer that costs about 60 USD and offers the computing power of a smart phone in a case about the size of a deck of cards. The software is a 100% free and open source system available for download at no cost preloaded with many useful apps and tools designed to protect your freedom, privacy, and user rights. These private servers are designed to create and protect freedom on the internet using a bundle of software packed inside one small, inexpensive box: a FreedomBox.

Kubernetes clusters increasingly host applications that manipulate data in persistent storage. Preserving that data is important but how does it get there in the first place? Unless it can generate its own data, the application should expect the volume to be populated prior to initialization. This may seem like a trivial problem with many simple solutions but we can build on kubernetes design principles to produce a superior solution. In this session you will discover a declarative PV population pattern, observe some concrete examples how this can be applied to different sources of data, learn about some common problems in this area and how kubernetes can help to solve them. After the session you will be ready to contribute your own populator to the kubernetes community.

The way how users can extend Libreoffice underperform the known usability from the office suite by a special kind of storage and a cumbersome way to load it. The talk will present one possible solution, open collaboration service, and show the improvements on both sides, the contributors who upload as well ideas on how users may easier customize and enhance the program.

Our extensions are hosted on a Plone-based content management site. The procedure to upload an extension is cumbersome as neither a wizard nor clear steps are provided. And also because the administration is hard work and a one-person show. Furthermore, the site lacks on good search and filter capabilities for the users and has no categories beyond Extensions and Templates. The talk will present two aspects: The first is how the open collaboration service works on https://www.opendesktop.org/ and the second part gives an idea how a tight integration into LibreOffice similar to GetHotNewStuff known from KDE might substantially improve the usability with also benefits for the development.

librehosters is a network of cooperation and solidarity that uses free software to encourage decentralisation through federation and distributed platforms. The values of the group connect transparency, fairness and privacy with a culture of data portability and public contributions to the commons.

In this presentation we show how people with interest in self-hosting, system administrators from not-for-profit initiatives and members of hosting collectives are federating practices and infrastructure outside of the commercial market. Early members of the recently bootstrapped network will be present to counsel the conversation.

A data-driven approach to reactive provisioning of immutable infrastructure will be outlined and put into context with the diverse needs of associated user communities in the network. This will allow to close with an outlook about how to preconceive a federated computational commons, in which user data is not tainted by hegemonic discourses.

After a session about so-called migration networks (of user data) at OuiShare Labs Camp #3 in 2015, the conversation continued between a flock of hosting providers independently. Over the years a list of awesome-librehosters quickly filled, which only underlined the need for a cooperative praxis around independently hosting user and community infrastructure.

With the emergence of the federated messaging network Matrix, different hosting providers interested in supporting distributed computation environments got in touch directly on the channel #librehosters:matrix.allmende.io and prepared a physical meeting over the course of the year 2018. This ultimately gave birth to Librehosters as an independent, informal entity.

In there, groups and individuals find a communication and exchange platform about practices of Self-Hosting in general, Docker Compose and systemd based hosting with libre.sh in particular, plus a prospect of a shared Kubernetes-based hosting environment. A data-driven approach to framing the conversation are the application catalogue and member directory.

The latter currently (26.11.2018) renders into

``` { "weho.st" : "https://weho.st/librehost.json", "Petites Singularités" : "https://ps.lesoiseaux.io/librehost.json", "lain haus" : "https://lain.haus/librehost.json", "Indie.Host" : "https://indie.host/librehost.json", "aktivix.org" : "https://aktivix.org/librehost.json", "Webarchitects Cooperative" : "https://www.webarchitects.coop/librehost-api/librehost.json", "hackerspaces.be" : "https://hackerspaces.be/librehost.json", "snopyta.org" : "https://snopyta.org/librehost.json" }

```

and presents the beginning of a wider federation of computing resources. One can imagine a directory per offered service, where producers of FLOSS can find an easy to find, maybe even canonical place for hosting offers of their respective applications.

The movement inbetween the Librehosters leads to a convergence of documentation and practice within the field of self-determined hosting, which eases the sharing of use cases and appropriate answers to reappearing needs. General acceptance receive federated platforms, such as file, calendar and contacts sharing with Nextcloud, microblogging with Mastodon, instant messaging with Matrix/Riot, but also the communication and collaboration environments Discourse for post-email, web-native discussion spaces and CodiMD Markdown pads alike.

The convergence of hosting practices within a self-determined network of practitioners taking care of user data helps with achieving data portability between platforms and providers, provides a social network for security training & mutual audit and enables a commoning of process and resources within the hosting communities to construct shared infrastructure.

How to join the network?

The librehosters network is work in progress at this point. The first gathering kicked of the creation of the network, inspired by the CHATONS network in the french speaking world. Libre Selfhosters are also welcome in the network.

How to participate in the project?

We currently have a discussion ongoing at talk.libreho.st and are developing tools at lab.libreho.st. A list of librehosters will soon be published at libreho.st/librehosters. If you would like to be included in this list please add a librehost.json file to your projects website and add the project itself to the librehosters directory repository.

IGT recently underwent quite a few changes. The name is now vendor-agnostic, meson is the new default build system, we are on the GitLab, and the new runner, a piglit replacement, has landed.

So what's up with the name change from "Intel GPU Tools" to "IGT GPU Tools"? Is it just GNU, with its sweet recursiveness, being that inspiring or do we really belive that having a vendor agnostic test suite that benefits the whole DRM subsystem is important?

Let's also talk build system. Everyone, and their dog, is switching to Meson nowadays, so we have too jumped on the bandwagon. How has the switch went? How does Meson compare to autotools? Are we going to remove the old build system... and when is that going to happen?

GitLab and its CI/CD pipleine allows us to generate and publish documentation efortlessly, get us cross-compilation working and run some post-merge autotools/meson consistency checs.

There is also the new runner. Are we suffering from "Not Invented Here" syndrome or it there actual, compelling reason to do all the extra development? This allows us to drop Python as a dependency and have a way to run a single binary with multiple subtests in one go, instead of spawning a new process for each subtest which does the same initialization, and shaving off those sweet sweet seconds so we can squeeze even more CI runs in a day.

GStreamer is a popular framework of choice for multimedia programming in the Linux world, especially for embedded. Since efficiency is a typical core requirement for embedded solutions, traditionally C/C++ have been the languages of choice for writing GStreamer applications and plugins. Unfortunately, this efficiency comes at the price of safety. Even the most skilled C/C++ developers make mistakes with memory management and the results could potentially be catastrophic. Thread safety is another aspect that is central to multimedia solutions but is extremely difficult to achieve with C/C++.

Rust language is designed to be both efficient and safe at the same time. In this talk, Zeeshan will present how GStreamer's Rust bindings not only make multimedia programming a lot safer, easier and fun but also allow developers to write even more efficient code than C/C++ in certain cases.

Numerous small villages in Austria have lost their connections to the railway network because it was no longer cost-effective to operate under a regular schedule. To re-establish these connections, FH Campus Wien started the project "autonome, schienengebundene, on-Demand, open-Track Systeme" AuSoDoTS (Autonomous rail bound on-Demand Open Track systems). The project's objective is to develop a concept for how to safely operate small autonomous trains, without a fixed schedule. Trains are only approaching to stations when a passenger explicitly requests them by pressing a button at the station or using a mobile app. A short track from Liesing at the edge of Vienna to Kaltenleutgeben, a small town in Lower Austria, could be one of the first test locations.

As a first approach a small model railway has been built. The model has two purposes. One is to find the optimal placement for passing loops where trains can pass each other, since the connection is mostly single track. The other is to test different scheduling algorithms for on-Demand service. To fulfill the strict safety aspects of a passenger transportation system, the programming language Ada is used and in following versions SPARK will be used as it can be formally verified to be correct then.

Minimalism matters in computing. To trust systems we need to be able to understand them completely. Openssl heartbleed disaster was caused by code no longer being minimalistic, even if it is free and open source software. Hardware manfucturers and proprietary closed source solutions make things even worse with expectations of intrusion to privacy and backdoors if we don't aim for free hardware, software and minimalism. In this talk I will discuss minimalism in a broad context and narrow down on what the free software community can aim for.

At the core of fast network packet processing lies the ability to filter packets, or in other words, to apply a set of rules on packets, usually consisting of a pattern to match (L2 to L4 source and destination addresses and ports, protocols, etc.) and corresponding actions (redirect to a given queue, or drop the packet, etc.). Over the years, several filtering frameworks have been added to Linux. While at the lower level, ethtool can be used to configure N-tuple rules on the receive side for the hardware, the upper layers of the stack got equipped with rules for firewalling (Netfilter), traffic shaping (TC), or packet switching (Open vSwitch for example).

This presentation reviews the needs for those filtering frameworks and the particularities of each one. Then it focuses on the changes brought by eBPF and XDP in this landscape: as BPF programs allow for very flexible processing and can be attached very low in the stack—at the driver level, or even run on the NIC itself—they offer filtering capabilities with no precedent in terms of performance and versatility in the kernel. Lastly, the third part would explore potential leads in order to create bridges between the different rule formats and to make it easier for users to build their filtering eBPF programs.

MySQL Replication is powerful and has added a lot of advanced features through the years. In this presentation we will look into replication technology in MySQL 8 and variants focusing on advanced features, what do they mean, when to use them and when not, Including

When should you use STATEMENT, ROW or MIXED binary log format ?

What is GTID in MySQL and MariaDB and why do you want to use them ?

What is semi-sync replication and how is it different from lossless semi-sync ?

What are the different parallel replication options and when do they excell ?

Why delaying transaction commits can improve your application performance ?

How is MySQL Group Replication is different from standard replication and Galera ?

This presentation is for audience well familiar with MySQL Replication and looking to expand their knowledge in deeper replication topics.

Java has evolved significantly in the past 20+ years. Users still want to run highly scalable monolithic applications, but now they also want to run in the cloud with fast startup and small footprint. Checkpointing will solve at least half of that problem. I'll show you how to checkpoint your java application and then restore it on a different machine, or several different machines. An application that might take minutes to warm up, can be warmed up, garbage collected, etc and then checkpointed. Users can restore Java processes in ms. I'll give an overview of CRIU (Checkpoint Restore In Userspace) a Linux utility that Java checkpointing is based on, present the proposed Java API, and then demo some interesting use cases.

We present Cogito, a mobile app that helps you remain in control of your identity. It supports a friendly way to identify yourself to websites, perform blockchain transactions and encryption. But most importantly, it guarantees that your identity is really owned by you. We believe this to be a good starting point for true privacy online.

Identity may seem like a boring topic. Haven't we solved the problem of how to identify ourselves to websites a hundred different ways? Isn't this a solved problem?

We argue that in order to guarantee true privacy it is essential to introduce new ways to identify ourselves.

We present Cogito, a mobile app that helps you remain in control of your identity. Use it to create multiple facets of your identity to separate for instance your working life from your personal life.

Traditionally, identities are bestowed on you by others. Your passport is issued to you by your government. Your bank account is given to you by a bank. Website credentials are given to you by the owner of the website.

These identities are ultimately not under your control. You get them on loan from the institutes that issue them, and they are free to retract them as they deem necessary. This is no basis for true control over your data. This is no basis for privacy.

With Cogito we've taken a cue from blockchains and PGP and use cryptographic identities. This involves generating a public-private key pair in which the public part is used as your identity (similar to a passport number or bank account number). The private key you keep to yourself because you can use it to prove that you are the owner of the identity.

These self-sovereign identities are created and maintained by their owners. They can not be taken away from them and are therefore completely under their control. We believe that this is a prerequisite for true privacy.

With Cogito we aim to make these self-sovereign identities very easy to use. Using a Cogito identity on a website is therefore as simple as scanning a QR code. Signing a blockchain transaction or decrypting data is as simple as pressing the 'accept' button.

In our FOSDEM session, we will demonstrate not only how Cogito works, but also what developers can do with Cogito. We will discuss the architecture, show the demo app and the tutorial. We invite those who are interested to help develop Cogito further.

During this talk we'll get a good understanding of Game Boy programming by reverse-engineering a ROM using Forth. We go beyond just decompiling the ROM to assembly and show how we created a cross-compiler that allows writing Game Boy games in Forth as well. You'll get to see how Forth interacts with the Game Boy hardware, and how the language can be extended to easily render sprites or play sounds for example.

We show you how to use Forth to incrementally refactor Game Boy bytecode into higher levels of abstraction. No black boxes. No magic. This way you can understand and appreciate every layer of the hardware and CPU instructions one by one. A similar approach can help you understand other systems (NES comes to mind) and create a language that is more comfortable than ASM or C to work with.

The talk is accessible to developers without former Game Boy, Forth or compiler experience.

Topics covered: - Go through the basics of Game Boy hardware - Explain how rendering graphics works on a Game Boy - Outline the challenges of working with the Game Boy memory - Show how to reverse-engineer a binary using Forth - Describe the process of writing the cross-compiler - Talk about using GBForth to write Game Boy games

D-Wave's Ocean software tools are an open source ecosystem for solving customer-scale problems on the quantum computer.

The D-Wave System solves a particular problem - the Binary Quadratic Model (also known as the QUBO or Ising problem). We will provide an overview of the open source tools that are used to express your problem as a BQM and to convert that BQM into something that can be solved by the quantum computer.

Finally we will motivate open sourcing these steps, and discuss the areas that interested users can participate in the project.

We love minimalistic languages because they let us do so much with so little. But when we start doing a lot with them, often we start yearning for types to help us make sense of it all. Adding types to a minimalistic language (well, adding anything!) makes it larger. Is this worth the price? Is a rich type system antithetical to minimalism? Let's find out!

This talk is based on the experiences in the development process of Titan, a statically-typed Lua-like language.

LibreOffice was announced in September 2010 as a fork of OOo, by a group of active members of the OOo community who were worried by Oracle acquiring Sun. They decided to create an organization capable of growing the LibreOffice project based on five founding principles: copyleft license, no contributor agreement, meritocracy, independence from vendor(s), and community governance. The talk will cover the history and governance peculiarities of The Document Foundation.

The Document Foundation (TDF), based in Germany, is the not for profit home of LibreOffice and the Document Liberation projects. Although is a German foundation, it has members who are at the same time the owners of the foundation and those who decide the governance, as they elect the Board of Directors and the Membership Committee from a list of candidates who have to be TDF members. TDF is based on five founding principles: copyleft license, no contributor agreement, meritocracy, independence from vendor(s), and community governance. Governance and statutes are hevily influenced by the previous experience at OOo, i.e. there isn't any community manager, there aren't any formal roles, and there isn't any formal mechanism for involving people (which makes people involvement a challenge). On the other hand, the community is growing nicely even without these people being appointed and a specific mechanism, but of course there are some issues like in any other community. The talk will briefly summarize the challenges we had to face in term of governance, and hopefully foster a discussion on the topic.

How do you create privacy tools that work for people all over the world, who are fighting many different struggles for liberation? We will talk about how we empower users with open design and community help at the tor project. We'll share our process during the development of Tor Browser 8 and explain why the way we work defines the product we release.

To make useful software, especially software that aims to keep people safe, it is essential to understand users’ contexts and goals. As part of our global south initiative, members of the Tor user experience and community teams traveled through India, Uganda, Colombia, and Kenya to run usability testing. We ran in-person testing of several user experience (UX) improvements in Tor Browser 8.0 with users of different technical backgrounds. We conducted more than 45 interviews that gave us an understanding of the diverse mental models and technical levels of knowledge of our users. We met people like Juana, a coffee farmer in Colombia who is part of a self-managed group of women coffee growers. The group uses Tor to communicate securely with one another. We met Jon, an environment activist and journalist in Hoima, Uganda who uses Tor to anonymously publish his blog. We learned about several threat models of the people we spoke to in Uganda. Concern about local police retaining hardware devices, and the practice of the political party currently in power seizing journalists notes and other records were common in most of those communities.

In addition, this work allowed us to speak with people using our software in extreme conditions, such as poor telecommunications infrastructure, very expensive data packages or very old hardware. This helped us to understand their context, empathize, and consider solutions that work for them. We believe that Tor Browser must be usable by people without a technical background, as well as by advanced users. We want to empower our users through education so that they can have control of their browsing.

We use an open design process where developers and designers work together to achieve the best solution. We use knowledge gained from our research to help us to create the most usable flow for users.

We will talk about the iterations and improvements we released in Tor Browser 8: the security indicators for .onion sites, the circuit display and the onboarding for new users.

Tor is an important tool providing privacy and anonymity online. The Tor network itself is only a part of what Tor is. Tor also provides privacy at the application level through the Tor Browser. The Tor Browser was designed to provide privacy while surfing the web and defend users against both network and local forensic adversaries. The same properties can be adopted by applications and services wishing to integrate the tor network in their architecture. Furthermore, onion services provide better authentication and assurance of who you are talking to. With onion services Tor can provide bi-directional anonymity by making it possible for users to hide their locations while offering various kinds of services, such as web publishing or an instant messaging server. This talk is going to explain how it is possible to integrate tor and build onion applications.

or is an important tool providing privacy and anonymity online. The property of anonymity itself is more than just providing an encrypted connection between the source and the destination of a given conversation. Encryption only prevents the content of the communication between Alice and Bob from becoming known. There is in fact a lot of information that can still be learned by just observing encrypted communications. For example, it is always possible to guess certain information by learning some properties of the conversation beyond just the content, such as the length of the conversation, or who was involved, or even guessing a group of people that communicate with a certain frequency. These properties are called metadata and can be used to describe information even when the full data is not available.

Anonymity is a broad concept, and it can mean different things to different groups. The main advertised property of the Tor network is that it provides strong anonymity given a variety of people using the network. For the Tor network to function properly and to satisfy users' needs, we need a certain degree of diversity. We need diversity in the nodes relays comprising the network and in the user population sending traffic through it. Lately, we have been introducing new traffic scheduling features in the network in order to solve problems, reduce congestion, and improve overall performance. The Tor network itself is only a part of what Tor is. Tor also provides privacy at the application level through the Tor Browser.

Other applications can also make use of the Tor network to be more secure. Onion services provide better authentication and assurance of who you are talking to. In this case, Tor can provide bi-directional anonymity by making it possible for users to hide their locations while offering various kinds of services, such as web publishing or an instant messaging server.

This talk is going to introduce what it does mean to do web development with privacy in mind. We will start by presenting a few example of applications that use onion services and follow up with tips on how to integrate onion services in your architecture and how to provide a seamless frontend experience for privacy-concerned people that prefer to use the Tor Browser.

GStreamer is the de-facto multimedia framework used for embedded Linux systems. I will focus on recent improvements relevant to the embedded community. I'll explain our progress in the Video4Linux support, in particular support for encoders. I'll talk about various optimizations thas have been happening and how they can help embedded developer deliver better devices. Finally, I'll will look forward at the next releases. I'll also discuss the on-going effort to add embedded systems into GStreamer's Continuous Integration & Automated Testing system.

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

This talks targets everyone who cares about Free and Open Source multimedia on embedded systems. GStreamer is the standard multimedia framework, not only on the Linux desktop, but most importantly, in embedded Linux products.

The widely adopted Open vSwitch implements the OpenFlow forwarding model. Its simple match-action abstraction eases network management, while providing enough flexibility to define complex forwarding pipelines. OpenFlow, however, cannot express the many packets processing algorithms required for traffic measurement, network security, or congestion diagnosis because it lacks a persistent state and basic arithmetic and logic operations.

This talk presents Oko, an extension of Open vSwitch with support for BPF actions. We implemented a first userspace prototype over Open vSwitch-DPDK. Our userspace BPF VM relies on the ubpf project, extended with a rudimentary verifier and support for persistent data structures (BPF's maps).

We compare the performance of our prototype for several packet processing applications with a second setup in which applications run as secondary DPDK processes exchanging packets with Open vSwitch over a shared memory (zero-copy DPDK Ring Port setup). Our Oko setup offers a near 2x performance improvement over this alternative setup.

Improving LibreOffice quality together. A summary of what happened in 2018.

LibreOffice has currently an large set of help pages which are hard to maintain and to edit. On the other hand the XML language used was designed for a broader purpose and is not used in its full capacity. The lecture presents simplifications of the help XML and the design of specific XML objects to describe the user interface and to connect the help pages closer to the dialogs of the application.

Software user interfaces has menus, toolbars, panes, dialogs, mouse clicks ad even voice to enable complex tasks for the user. Because of the cost of the screen real-estate, elements of interaction are concise either in textual form or in pictorial form (icons). The need of Help pages are necessary to give more details on the elements functionalities. But since the set of UI elements is limited in size, the elements of the Help pages should also be limited, and the corresponding help page element to UI element should be connected.

The lecture presents simplifications of the help XML and the design of specific XML objects to describe the user interface, to connect the help pages closer to the dialogs of the application and produce Help contents in a faster way, making easier to upgrade and to address softwares translations processes.

With IaaS, common way to provide compute resources is to ask the hypervisor to allocate a bunch of VMs for you. Sometimes, however, allocating a bare metal machine could be essential to withstand higher workloads or harden data security. Running a container engine (like k8s) inside of a bare metal machine avoids double resource management and achieves higher density.

In this talk we will introduce the OpenStack project called Ironic - the bare metal provisioning and life cycle service that can also act as a hypervisor for the OpenStack compute service.. We will explain system design, typical hardware management workflow, upcoming features and future challenges.

A few years back Wayland started to change the open source graphics stack in Linux. Today a few major Linux distribution are already using wayland as default window system. Also in In-Vehicle-Infotament(IVI)systems Wayland becomes popular, several projects are already successfully launched, popularity is growing and bigger automotive communities like Genivi and AGL are participating. IVI environment is quite different for the Desktop on and one of the important difference is in the window or application management. Weston as an open source reference implementation of wayland compositor cannot be used directly and needs some adjustments. To address this point ivi-shell was introduced to Weston and provides a possibility to realize IVI specific use-cases. I would like to present the available implementation and talk about upcoming use-cases like virtualization and distributed HMI

In this talk, we will discuss Miguel’s pet projects to build console applications. To this day Miguel continues to use Midnight Commander, and he wants to bring the joy of developing user interfaces in consoles to the world of .NET programmers.

(Please note that this replaces the talk 'Do you think is easy to create a console app?' by Eduard Tomàs.)

Supervisor Binary Interface (SBI) is one of the most fundamental interfaces in RISC-V eco-system. It allows the operating system to interact with the supervisor execution environment (SEE). The SEE always runs in higher privileged mode than the supervisor OS. It can be a simple bootloader in low-end hardware platform, a hypervisor-provided virtual machine in a high-end server, or simply machine mode software in bare metal systems. An unchecked rapid development of many RISC-V systems could lead to incompatibilities between different systems SEE, preventing the use of a common OS binary image.

The RISC-V ISA has defined SBI to provide a cleaner interface for the supervisor OS which makes virtualization and bring-up of new hardware platforms much easier. In hypervisor extended supervisor (HS) mode, an OS or hypervisor interacts with the machine through the same SBI as an OS normally does from supervisor mode. An HS-mode hypervisor is expected to implement the SBI for its virtualized supervisor (VS) mode guest. The current RISC-V SBI only defines a few mandatory functions such as inter-processor interrupts (IPI) interface, reprogramming timer, serial console, and memory barrier instructions. Many important functionalities such as CPU/system power management are not yet defined due to difficulties in accommodating modifications without breaking backward compatibility with the current interface.

This talk presents the ongoing work to make SBI an extensible yet robust specification. The proposal to extend SBI is based on the foundation policy of RISC-V i.e. modularity and openness. It will always be backward compatible with previous versions including the existing aka legacy version. To achieve that, the focus will be only to develop a Base SBI extension that will contain feature list, version and vendor type queries. Once that is ratified, the future extension such as CPU/system power management, vendor extensions can be developed in parallel. The use cases and calling convention of these extensions will be discussed in details. We will also talk about a reference implementation i.e. OpenSBI for the SBI specification. This project will be licensed under most permissive software license which will allow everybody to reuse the OpenSBI code base in their favorite software eco-system in whatever way choose to do so. This will help in reducing SBI fragmentation in future as well.

In the spirit of the open design nature of RISC-V, the goal of this presentation is to continue the open discussion leading to the formalizing RISC-V SBI specification simplifying both hardware and software designs and doing so, contributing to further development of the RISC-V ecosystem.

Hands on Go debugging with Delve. Less slides, more substance: this talk will be focused on live demos that the audience is invited to participate in. Come learn advanced debugging techniques and the intricacies of the Delve debugger.

In this talk I will present several demos, all of which will be available online. Each demo will target a specific use case of Delve. The goal is for audience members to walk away with an expert level understanding on the usage of the Delve debugger. During the course of this talk users will be guided through basic to very advanced usage of Delve, exploring features they may not have used, or known existed!

Topics covered will include basic debugging, tracing, advanced Goroutine debugging, panic debugging, general advanced debugging and low-level debugging (exploring registers, disassembly, etc). Each demo will have an accompanying program that will be hosted online and available for everyone to download to enable everyone to follow along.

Global Consent Manager project is a collaboration between Mozilla, University of Missouri and University of Nebraska Omaha. The result is a browser extension prototype that helps with managing of GDPR cookies and consent dialogs across trusted websites.

Description of how consent management on the web works today, and the relationship between user privacy and reputable content providers. Web users face a confusing array of data sharing choices, and click fatigue can lead to poor user experience and possible inadvertent selection of options that do not match the user’s privacy norms. Reputable content providers face revenue disruption arising from changing data privacy regulations.

In this session, we will discuss how to improve the consent experience. New standards for user control of data sharing present an opportunity for sites trusted by users to work together with browsers to implement data sharing choices that provide a better experience and a more accurate reflection of the user's privacy preferences.

In this talk we describe our experience of bringing up embedded FreeBSD for a heterogeneous 32/64-bit RISC-V system using LLVM, which was more difficult than you might expect. We look at the practical engineering steps needed to bring up an embedded operating system where many of the key components are not fully mature. The result is a reference embedded FreeBSD implementation for RISC-V, freely available to the community.

We were tasked with bringing up and testing embedded FreeBSD on a custom five-core 32/64-bit RISC-V processor using LLVM. Given FreeBSD has already been ported to RISC-V and LLVM is the standard BSD C/C++ compiler surely this should be easy.

But it wasn't. LLVM for RISC-V is still relatively immature, particularly for 64-bit. FreeBSD runs on symmetric multi-core 64-bit QEMU RISC-V, but not on embedded systems and not on heterogeneous multicore systems.

In this talk we'll go through the steps needed to bring up a functioning embedded FreeBSD system on multi-core heterogeneous RISC-V system. Our target hardware was not available at the start of the project, so we used the generally available HiFive Freedom Unleashed board. The result is a reference embedded FreeBSD implementation for RISC-V, freely available to the community.

This is not a talk about the deep internals of FreeBSD, but about the practical engineering steps needed to bring up an embedded operating system where many of the key components are not yet fully mature.

Row-based binary log is mostly used as a logical replication log for MySQL. However, ever since row-based replication was introduced, it has also been widely used as an integration point between a MySQL server and other components in an IT infrastructure. It is often used as a capture-data-changes stream, as a source of data for extract-transform-load operations or even as an event notification trigger (e.g., propagating transaction information to proxy layers).

Commonly deployed setups revolve around collecting/subscribing to data changes and propagating these to downstream consumers through a message bus, like Kafka for instance.

This session will present such use cases, highlighting the additional metadata added to the binary log in the latest releases, explain how to efficiently make the most out of these and how to optimize the implementation of a change capture procedure. We will also showcase a couple of example plugins that tap into the server's binary log stream and export it even before it reaches the binary log files.

Emitter: scalable and real-time networking for IoT, web apps and gaming. Open source or cloud based.

Emitter.io is a real-time messaging service for connecting online devices. It is a scalable, fast and secure pub/sub in Go.

Emitter.io is a real-time messaging service for connecting online devices. - scalable: Built to handle millions of messages per second and to scale horizontally. - Fast: Designed to ensure reliable, speed-of-light message delivery and high throughput. - Secure: Supports TLS encryption, binary messages, expirable channel keys and permissions. - Open source: Source code is available on GitHub and packaged as a docker container. - Persistent: Messages can be stored for a period of time and sent to subscribers on demand. - No more limits: Uses standard MQTT protocol, supports message filtering.

Accessing D-Bus services from .NET.

D-Bus provides a bus for accessing system and desktop services.

In this talk we'll use Tmds.DBus to access those services from .NET Core.

Tmds.DBus is a fork of dbus-sharp, updated with asynchronous programming patterns introduced in .NET 4.5.

The library comes with a cli tool that generates a strongly-typed representation of a D-Bus service.

We'll build a small example application that consumes a D-Bus service.

Virtio 1.1 was released recently and it brings some exciting new features, pushing forward performance and hardware implmementations of Virtio. In this talk we will look into what happened since FOSDEM 2018 and also look at which features are on the horizon and can be expected soon.

Virtio is a common framework for IO virtualization in hypervisors. It is part of DPDK accelerated Open vSwitch and allows for hardware abstracted VNFs. In the past year version 1.1 of the Standard document was released and the additions focused on support for hardware implementations and performcance improvements. This talk will give an overview of new features and will also give a quick introduction into how interested parties can participate in work on the Virtio specification.

EFL is a graphical framework that is used on a lot of TVs. The challenge with a TV is, that it needs to be operated with a remote control. Which means, every selectable element on the screen has to be connected to a parent element (i.e. it needs to have a way to navigate to and from itself). In other words, it can be accessed just by pressing the 4 navigation keys on your remote control.

To achieve this, graphical elements on the screen are grouped into graphs, which are then connected together after the creation process.

The talk will cover:

· how the set of graphical components (or elements) on the screen are separated into smaller graphs; · look at how they are connected together; and · show why caching calculation results is now easier to cache, than in the previous system.

Ever tried developing Java applications in containers?

Of course not. You're a sensible person.

From a small footprint to a super-fast spin-up time, the reality of containers is a far cry from the reality of an OpenJDK binary execution.

So how do we bring these two disparate visions closer together?

Simple! We jlink the required JDK modules to generate a smaller footprint, then leverage alternate JVMs for performant startup!

I promise, the reality is simpler than that sentence. :)

Drop by and see what I mean.

Luerl is an implementation of standard Lua 5.3 written in Erlang/OTP. Lua is a powerful, efficient, lightweight, embeddable scripting language common in games, IoT devices, machine learning and scientific computing research.

The Luerl VM is a mixture of interpreting Lua VM instructions and using Erlang directly to implement function calls.

Through the use of Erlang functions, Luerl can be augmented to cope with a wide range of different domains, creating a customized language sharing a syntactical framework.

This talk presents an overview of the open source project "Leela Chess Zero" (Lc0), a new type of chess engine based on the AlphaZero paper released by DeepMind. Lc0 learns to play chess solely by playing against itself without any human knowledge or intervention. Starting from scratch with random moves, its play improves each iteration using a powerful combination of reinforcement learning and neural networks. We rely both on an active open community for the code and computing resources as many petaflops are required to train a solid neural network. Currently the engine is among the four best in the world.

Who is Valkyrja, and what is she like? Why did she choose .NET Core on Fedora? Her mum will tell you the story, about Valkyrja outgrowing the Raspberry Pi and what kind of diet she went on to stop eating up all the performance of an expensive VPS.

Story driven presentation of a small open source project with character and all the obstacles she had to overcome.

There have been a number of exciting developments in NetBSD and pkgsrc in the last year. This talk will give an overview over some cool recent developments, new features and show some exciting hardware to run NetBSD and/or pkgsrc on.

NetBSD 8 has been released, and perhaps there will be a -9 release in time for FOSDEM!

64-bit ARM support is improving quickly. There is exciting new hardware (such as the Pinebook) to use NetBSD on, plus ARM cloud instances on Scaleway and EC2.

pkgsrc has gotten a lot more packages, of course, but there have been other improvements.

In August 2018, Redis Labs relicensed a number of AGPL-licensed Redis modules with the "Commons Clause" amendment on the grounds that it prevents abuse and therefore ensures the sustainability of its development.

As this renders the software no-longer free and open source, GNU/Linux distributions such as Debian and Fedora are unable to ship Redis Labs' versions of the affected modules to their users.

This talk from a long-time (2009) Redis user & developer will outline the history, background & response to this flavour of license, as well explain how this it at odds with communities in which they participate in and are ultimately are a short-sighted & retrograde step for the companies and individuals that are advocating for them.

Furthermore, this talk will ask some thought-provoking questions about how the the conversation around "sustainability" in open source is being co-opted by foregrounding of financial elements to the detriment of the principles & people that have so clearly and demonstratively served us so well in the past four decades.

This talk introduces the BASIC Engine, a very low-cost single-board home computer with advanced 2D color graphics and sound capabilities, roughly comparable to late-1980s or early-1990s computers and video game consoles. It can be built at home without special skills or tools and using readily available components for under 10 Euros in parts, or mass-produced for even less.

Mattermost is an open source, enterprise-grade messaging platform with thousands of contributors. At Mattermost, we set out to build a platform that would support a variety of extensions. Ranging from simple webhooks accepting curl commands, to bot and integration frameworks, a rich plug-in architecture across server and client experiences, to full access to system APIs with language-specific drivers. All of this is built on top of an open source engine with an open and accessible data model in SQL. We’ll chat about our approach to extending the platform as well as tools, technologies, and best practices for developers writing integrations with our developer toolkit.

After several years of only occasional progress but mostly stagnation, resources have now been available for work on a LibreOffice-based app for iOS. This talk will describe the history and technical aspects of the effort.

Collabora Office for iOS is based on the C++ server-side code for Collabora Online (based on LibreOffice Online), and JavaScript code for the same (browser-side). Plus the core of Collabora Office (i.e. LibreOffice). Plus, finally, a rather small amount of glue code in Objective-C++. In the app all this code runs on the device, there is no server involved.

Work on enabling compiling the LibreOffice core for iOS (cross-compiling, on a Mac, as all iOS development is done) was started originally back in 2011, by me. Initially this was mostly done in spare time, for fun.

There was initially no clear product plan and no technical exact plans how, once the core code works on iOS, it can and would be used in an actual app. No work on any user interface. But just making the functionality needed to even load and save documents on iOS, for instance, was challenging enough, given the somewhat obscure and complex internal plumbing of LibreOffice with its long history.

Some year later, for Collabora Online, the concept of “tiled rendering” was introduced by Michael Meeks. In this approach a client requests the core to render a document as “tiles”, rectangular pixmaps. The user interface in Online, in JavaScript, requests and displays these tiles and provides the user interface that send user input and edit request as necessary to the core.

Also in the same timeframe, the CloudOn company needed an iOS app with the ability to load and edit office documents natively on an iOS device. We started working on making the LibreOffice core useful for that, based on my earlier work, and using tiled rendering for this, too. One major challenge here turned out to be the massive size of the LibreOffice core code, which was problematic as Apple at that time restricted the size of the executable code in an iOS app quite severely. Anyway, various workarounds were found, and this was progressing nicely, but then CloudOn was acquired and lost interest. No public iOS app code was released from that.

As a test so see that the code works at least to some extent, I had written a minimal test app (without any actual editing UI), “TIledLibreOffice”, in the LibreOffice core code.

Then no iOS work happened until a few years later when Jan Iversen got interested. He was at the time working for TDF. He worked on an iOS app, LibreOfficeLight, which is still present in the LibreOffice core code. He also worked on keeping the iOS functionality working in LibreOffice. Jon Nermut also helped. The LibreOfficeLight app as such worked but did not contain any actual editing functionality.

Then half a year or so later, Michael started toying with the idea of re-using the by now quite substantial JavaScript UI we have in Online in an iOS app. And then a customer turned up that took part in funding it, Adfinis SyGroup.

I started working on that, and it turned out to be surprisingly straightforward to get it working. Sure, there were lots of technical issues involved. Some of the iOS code in LibreOffice had bit-rotted over the years. The Online server code normally runs as multiple separate processes on a Linux machine. That had to be combined into code running in just one process (the iOS app) which was challenging.

The JavaScript code in the iOS app is the same as that in Online. There are very few places where the JavaScript needs to know that it is running in an iOS app and not in a browser.

All the code is Open Source and publicly available, in the LibreOffice “core” and “online” git repositories.

The D-Wave Hybrid is a general, minimal Python framework for building hybrid asynchronous decomposition solvers of quadratic unconstrained binary optimization (QUBO) problems. Designed in the spirit of the dataflow programming paradigm, and built atop the Ocean SDK primitives, it provides a simple workflow construction, execution and instrumentation environment that enables rapid development and tuning of hybrid applications running across classical and quantum systems. In the talk, we'll briefly discuss the motivation for some of our architectural decisions, briefly present available submodules, features and building blocks, only to focus on describing several interesting use cases (hybrid workflows).

With the advent of the IoT, are we really making our lives simpler or diving ourselves in a vast ocean by uploading our lives to the internet? Project Things is an experimental framework of software and services from Mozilla for connecting "things" without any Middleman.

Mozilla is working to create a Web of Things framework of software and services that can bridge the communication gap between connected devices. By providing these devices with web URLs and a standardized data model and API, we are moving toward a more decentralized Internet of Things that is safe, open and interoperable. Using the Internet of Things today is a lot like sharing information on the Internet before the World Wide Web existed. There were competing hypertext systems and proprietary GUIs, but the Internet lacked a unifying application layer protocol for sharing and linking information. The “Web of Things” (WoT) is an effort to take the lessons learned from the World Wide Web and apply them to IoT.

From this talk audience will take away an understanding of the privacy concerns related to IoT, and how they may be putting their personal information at risk by connecting my physical entities to the internet and how project things come to the rescue. The goal is for visitors to leave with a better understanding of some of the issues surrounding the Internet of Things today, and how Mozilla is working to build a decentralised IoT with the Web of Things, to improve interoperability, privacy and security through standardization. Visitors

Project Things initially focuses on developing three components:

1. Things Gateway — An open source implementation of a Web of Things gateway which helps bridge existing IoT devices to the web
2. Things Cloud — A collection of Mozilla-hosted cloud services to help manage a large number of IoT devices over a wide geographic area
3. Things Framework — Reusable software components to help create IoT devices which directly connect to the Web of Things

A) Without Demos

Time Duration: 20-40 mins (flexible depending on the time allocation) Talk Structure: A.Without Live Demos:

• General Discussion on What Is IoT and its future.
• The pros and cons of connecting things to the internet.
• How exploiters can breach the security and know our lifestyles.
• Introduction to project things
• Details about the project things framework.
• How project things is secure and solve the problem of privacy and security

B) With Demos (can be converted to a workshop if needed)

• Points included above (without demos).
• Demo of DIY web things that makers can build themselves using the Things Framework. Examples will be shown using several low-cost developer boards such as Arduino, Espressif, BBC micro: bit, Adafruit Circuit Playground, and Raspberry Pi.
• Demo and discussion of Implementing basic IoT attacks (education purposes) : accessing the devices using the physical, remote or local network.
• Live demo & session on increasing security: Participants will learn how to increase the security and bypass few of these attacks.

Greenfield is a Wayland compositor running entirely in your browser. No plugins or black magic required. This talk will go into the conception, exploration and struggles of making this possible. The result is a product far from finished, but already capable of running existing Wayland applications directly in your browser.

Greenfield is a in-browser Wayland compositor capable of running existing Wayland applications in the browser. This is made possible by leveraging a large amount existing HTML5 apis.

Greenfield is different from existing solutions like VNC or RDP in that it does not stream a final server side generated image to a remote. Instead Greenfield live encodes each individual application to h264 frames using gstreamer. After encoding, frames are send to the browser using a dedicated WebRTC datachannel. On reception, the h264 frames are decoded using a WebAsembly h264 decoder running in a WebWorker while WebGL is used to do color conversion from YUV+A to RGBA. The end result are applications who's content is drawn in their own HTML5 canvas. As a consequence, the entire screen you see in the browser is actually composed of nothing more than ordinary browser DOM elements. All of this is done while adhering to the Wayland mantra 'Every frame is perfect'.

This lightning talk will showcase a new GStreamer plugin that allows applications to overlay HTML pages on top of video content. This plugin also allows to capture and interact with an HTML page in a live GStreamer pipeline, for recording purposes for instance.

Overlaying content on top of live video is common practice in the broadcasting industry nowadays. What if you could use HTML and Javascript for your overlay implementations? This would be possible with GStreamer and WebKit's WPE port combined in a GStreamer plugin.

GstWPE receives EGLImages from WPE and shares them as GstMemory objects attached to buffers injected into the pipeline. This approach enables applications to perform overlaying directly in the GPU using shaders. Alternatively the EGLImages can be downloaded to the CPU main memory using the GStreamer gldownload element and processed there.

GStreamer is an extremely powerful and versatile framework for creating streaming media applications. WPE WebKit allows embedders to create simple and performant systems based on Web platform technologies. It is designed with hardware acceleration in mind, leveraging common 3D graphics APIs for best performance.

Tasking in Ada provides an effective tool for shared memory parallelism. An "any time" algorithm is an algorithm that, given some more resources, will improve the accuracy of an estimate. For example, consider the estimation of Pi by a Monte Carlo method. With multitasking, the status of the running of an "any time" algorithm can be monitored without interrupts.

The programming concepts will be illustrated with examples of algorithms in polyhedral geometry. The demonstrated code belongs to the free and open source PHCpack, at https://github.com/janverschelde/PHCpack.

This meetup is to connect MuseScore users and developers, and have a hands-on session on all things MuseScore.

MuseScore is music notation software used by millions of musicians worldwide to create, play and print beautiful sheet music. MuseScore is easy to use, yet powerful, and creates professional-looking sheet music. MuseScore is licensed under GNU GPLv2.

MuseScore is available for Linux, Windows and Mac OS X, and is available in 50+ languages. It features an easy to use WYSIWYG editor with audio score playback for results that look and sound beautiful. It supports unlimited staves with up to four voices each, dynamics, articulations, lyrics, chords, lead sheet notation, import/export of MIDI and MusicXML, export to PDF and WAV, plus online score sharing.

https://musescore.org

Interested in managing virtual machines and containers using single integrated UI? See Kubevirt's web-based user interface in action.

Kubevirt Web UI will be presented.

Create, monitor and access VMs easily in a Kubernetes cluster. Discover k8s API objects relationships graphically. Enjoy wizards for common tasks.

RetroShare is a platform that allows users to create a fully decentralized network with a high level of security, privacy and confidentiality. It offers a unique combination of features (File transfer, publishing channels, forums, distributed chat, asynchronous email,...) that provide users lots of ways to interact. Its generic nature allows to create new services based on an existing cryptographic and networking backend.

The presentation will start with a short overview of the RetroShare software and motivate the need for a JSON API to safely access the features offered by the core of the software. Our JSON API, to be released in December 2018, uses clever techniques to automatically generate handles from existing code based on Doxygen capabilities as well as a very compact serialization technique. We will explore the potential of the JSON API with concrete examples including the --preliminary-- web interface and Android RetroShare clients. Finally, a call to developers will be made, based on generic examples, while proposing multiple ideas of distributed services to be developed on top of it.

The detailed plan for the presentation will be the following. Each line indicates the approximate time duration and number of slides. The presentation is tuned to approximately 20 mins.

Overview of the Retroshare platform

• Services offered by the application (FT, channels, forums, identities, etc)
• Architecture (libretroshare + Qt UI, main components)
• Motivation for a JSON API (use of RetroShare as a background library for decentralized communication, Android client, web interface, getting rid of old UI...)

The JSON API

• Automated serialization
• Automated JSON API code stub generation
• Interaction, syntax
• Authentication

Concrete examples

• RetroShare's new web interface
• Experimental mobile chat app based on RetroShare JSON API
• ElRepo.io App based on RetroShare JSON API

Call for contributions

• ideas of applications
• conclusion and contacts

Drivers are usually written in C for historical reasons, this can be bad if you want your driver to be safe and secure. We show that it is possible to write low-level drivers for PCIe devices in modern high-level languages. We are working on super-fast user space network drivers for the Intel 82599ES (ixgbe) 10 Gbit/s NIC in Rust, C#, go, OCaml, Haskell, Python, Swift, and a few more languages (WIP). All of our drivers are written from scratch and require no additional kernel code.

Check out our GitHub page with links to all implementations, performance measurements, and publications for further reading.

Supposedly modern user space drivers (e.g., DPDK or SPDK) are still being written in C in 2018 :(

This comes with all the well-known drawbacks of writing things in C that might be prevented by using safer programming languages. Also, did you ever see a kernel panic because a in-kernel driver did something stupid? It doesn't have to be that way, drivers should not be able to take down the whole system.

There are three steps to building better drivers:

• Write them in a safer programming language eliminating whole classes of bugs and security problems like bad memory accesses
• Isolating them from the rest of the operating system: user space drivers that drop privileges
• Isolating the hardware using the IOMMU

We are showing that it is possible to achieve all of these goals for PCIe drivers on Linux by implementing user space network drivers in all of the aforementioned programming languages. Our techniques are transferable to other drivers that would benefit from more modern implementations.

Our drivers in Rust, C#, go, OCaml, and Swift are completely finished, tuned for performance, evaluated, and benchmarked (they are about 80-90% as fast as our user space C driver which is as fast as older versions of DPDK).

The main thing to take away from this talk is: writing drivers is neither scary nor hard. You can write one in your favorite programming language, so go ahead and try that :)

We will introduce the work of Localization Lab and localization as a key element of bridging the digital divide. We will also discuss the essential connections between emerging connectivity in vulnerable societies, adoption of open source tools, means to oppose or prevent censorship and localization into local languages.

Only about 25% of the world's population speaks English natively or as a second language, however English still dominates over half of website content. This dominance also extends to Free and Open Source Software. While FOSS plays a large role in bridging the digital divide and bringing access to technology and the open Internet to new users around the globe, these tools and spaces are only as effective as they are linguistically accessible.

Over the past 5 years, Localization Lab has built a network of over 6,000 volunteers worldwide who localize open source, digital security and circumvention tools for communities in need. In this session we will share experiences we have had working with communities around the globe who are localizing digital security tools out of necessity, as language preservation, and as forms of activism. We will also discuss the importance of planning for localization in the early design stages and how you can improve your tools by harnessing the knowledge and experience of localizers as end users.

You should leave the session excited to promote language diversity in tech and on the Internet and with ideas for how you can improve FOSS localization efforts as a translator or a developer.

Using Sphinx doesn't necessarily mean using reStructuredText for input and HTML for output. We explore Sphinx's newfound support for Markdown as well as it's broad range output formats available, before moving onto an overview of how you can develop your parser and builder extensions.

Sphinx is the documentation tool of choice for an increasing amount of projects, both inside and outside Python. Thanks to the success of platforms like Read the Docs, building documentation with this toolkit has never been easier. Most people associate Sphinx with the reStructuredText syntax provided by docutils, and typically output documents to HTML and, occasionally, PDF. However, Sphinx is capable of so much more. Since Sphinx 1.8, it is possible to use source documents written in the CommonMark syntax, while the amount of builders provided both in-tree and out-of-tree continue to grow.

Through this talk, we explore how one can build their documentation using Sphinx and Markdown source documents. We detail the variety of builders available as part of the standard Sphinx installation and as third-party extensions, including some basic configuration tips for the more commonly useful ones like man pages and LaTeX/PDF. Finally, we provide a high-level overview on how you can go about writing your own extensions to parse other plain-text documentation formats and output in additional documentation format. The latter of these will touch on docutils, a foundational component of Sphinx, so one can understand the intermediate documentation model it provides.

It is a joy to build command-line tools that are not only easy to learn, but that other developers are willing to maintain. Often a team's engineering efforts are spent on the backend, while the cli doesn't receive the same level of attention. This can result in hard-to-test tools, and dumping maintenance of them to whoever most recently joined the team.

Learn how to take full advantage of popular Go libraries, structure your Go code to improve reuse and testability, publish binaries, and of course design your commands to be user friendly.

Slides are available at https://carolynvs.com/cli

After discovering Foreman Ansible Modules I've set up an Ansible Playbook to set up and configure Foreman and Katello. Once its up and running, it allows you to boot PXE machines, or image based using Packer and Gitlab. The lab is deployed on my laptop and showcases the following technologies:

• lifecycle management (create/update/delete machines)
• content management (Environments/Packages/Subscriptions)
• scheduled image building and delivery with a pipeline
• cloud-init
• immutable infrastructure

In other words, in this talk I will show how I manage foreman/katello/smartproxies with configuration management tools themselves.

Never is a simple functional programming language. Technically it may be classified as syntactically scoped, statically typed, call by value, functional programming language. In practise Never offers basic data types, assignment, control flow, exceptions, arrays, first order functions and some mathematical functions to make it useful to calculate expressions. The language itself is an example how minimalistic language can be created as a hobby project in several months and used to solve interesting problems.

The presentation outlines Never language features and presents its capabilities by demonstrating simple neural network supervised learning algorithm. During the talk audience will learn why the language was created, which solutions are used under the hood and about its possible future extensions.

Handling tens of thousands of database connections poses seriously performance issues on any database system because resources are poorly utilized. ProxySQL, a MySQL protocol aware, reverse proxy for database servers using the MySQL protocol, is able to track connections statuses and utilize very few connections to MySQL server to serve traffic from thousands of client connections. This session will focus on explaining implementation details and how this algorithm is able to boost performance.

France started to compile statistics about its trade in 1716. The "Bureau de la Balance du Commerce" (Balance of Trade's Office) centralized local reports of imports/exports by commodities produced by french tax regions. Many statistical manuscript volumes produced by this process have been preserved in French archives. This communication will relate how and why we used network technologies to create a research instrument based on the transcriptions of those archives in the TOFLIT18 research project. Our corpus composed of more than 500k yearly trade transactions of one commodity between a French local tax region or a foreign country between 1718 and 1838. We used a graph database to modelize it as a trade network where trade flows are edges between trade partners. We will explain why we had to design a classification system to reduce the heterogeneity of the commodity names and how such a system introduce the need for hyperedges. Our research instruments aiming at providing exploratory data analysis means to researchers, we will present the web application we've built on top of the neo4j database using JavaScript technologies (Decypher, Express, React, Baobab, SigmaJS). We will finally show how graph model was not only a convenient way to store and query our data but also a poweful visual object to explore trade geographical structures and trade products' specialization patterns.

By Paul Girard and Guillaume Plique. Sciences Po, médialab, Paris, France

Project funded by the French Agence Nationale de la Recherche (TOFLIT18)

https://tech.ebu.ch/news/2018/09/voice-controlled-hybrid-radio-demonstrated-at-2018-ibc

The EBU and NAB co-funded a project to create a demonstrator for a radio device able to be entirely controlled by voice. This demonstrates the concept of the 'Single Voice Service List', and uses openly-standardized metadata from the broadcaster (using RadioDNS lookup, ETSI 103 270, and the Service and Programme Information data, ETSI TS 102 818) to automatically select between DAB+/IP/FM. The project was implemented by hacking the underlying Alexa Voice Service SDK.

TypeScript adoption it's been a reality in the last years. This presentation is going to be an explanation on how we can take advantage of TypeScript compiler to have a smooth migration from JavaScript to TypeScript.

Maintaining big projects in JavaScript can be a hard task. Wouldn't be great if we could gradually migrate our applications to TypeScript? Having types and access to all features from the latest EcmaScript versions can help us scaling and maintaining our code. TypeScript compiler allow us to compile JavaScript code and at the same time takes advantage of definitions to make type checking. Using this features we can easily start migrating our code base to TypeScript over time avoid headaches.

Running Twitter services on Graal has been very successful and saved Twitter a lot of money on datacenter cost. But we would like to run more efficient to reduce cost even more. I mean, who doesn’t? In order to do this we are using our Machine Learning framework called Autotune to tune Graal inlining parameters. This talk will show how much performance improvement we got by autotuning Graal.

I will explain how to write your own device driver for the Mellanox Connect-X device family, why you might want to do this, and what lessons we learned when we wrote the driver for Snabb.

I will put this into context with other hardware and related technologies like AF_XDP, Intel AVF, DPDK, etc.

Good news! Hackers nowadays feel empowered to write our own 10G-100G ethernet device drivers. Github contains many such drivers written in languages including C, C++, Lua, Rust, and Go. Community projects successfully use these simple bespoke drivers to keep in control of our applications' software architectures.

The problem is that today these drivers mostly target aging hardware: the beloved Intel 82599 (Niantic) 10G family. Niantic is on the way out of the market and, surprisingly perhaps, there is no obvious successor for independent developers.

In this talk I will present the Mellanox Connect-X family as a potential successor to Niantic as the darling of independent driver hackers. I will tell you how we independently wrote our device driver for the Snabb project and why this driver works for all 10G/25G/40G/50G/100G NICs in the ConnectX-4 and ConnectX-5 device families. I will go into technical detail about how the driver and the hardware works in case you want to write your own driver one day too.

Together we will contemplate the merits of such a custom device driver in the context of related technologies like AF_XDP, Intel AVF, DPDK, and hardware from other vendors.

In HPC the memory available is still growing a lot with now soon TB of memory on one server. This is means more stress for the allocator and to underlying OS. This lead to more performance issue and mistakes on memory amangement handling in large applications.

Memory missusage is also an issue for more common application like desktop applications with large code base.

MALT is a memory profiling tool dedicated to memory management to provide temporal charts, global metrics and source code annotations. It comes with a nice web graphical interface to dig into the profile.

I made my PhD. developing a memory allocator for HPC application on large scale supercomputers. During this period I observed a lot of unperformant patterns and issues on existing HPC app. Mostly on a multi-million line simulation and worked a lot to support this in my memory allocator to improve things.

During my postdoc at the Exascale Computing Research Lab, I focused on implementing a memory profiler trying to show the user what the app is doing with the allocator and trying to provide ways to observe the common issues an mistakes in large scale apps.

It also uses an uncommon approach for such tools in HPC as it provides a web-based interface using tools like D3JS/Bootstrap/Angular and exposed by a small nodejs webserver. It permits to fix a big issue in HPC when running remotely as the GUI of the profiler needs to be X-forwared which make it slow, badly themed. Or to run locally without having our source code at the same place. The web server permit to easily ssh-port-forward the interface and eventually to work at many people remotely looking at the same profile. This also provides quickly a nicer rendering with less development overhead.

I used it a lot on my own development at CERN for a code scaling on 500 nodes and also shortly made a try on a large scale ~1.5 million line C++ application used by physicists there to check it didn't crash at this challenging scale. The tool currently limits himself to process analysis which means for an MPI app it dumps a profile file for each rank. But this is what is meaningful for memory management as a first step.

Kernel memory disclosures - also known as kernel information leaks - denote the inadvertent copying of uninitialized bytes from kernel space to user space. Such disclosed memory may contain cryptographic keys, information about the kernel memory layout, or other forms of secret data. In this presentation, we introduce KLEAK, our method to dynamically detect kernel memory disclosures. It utilizes a simple form of taint tracking, enhanced with compiler instrumentation as well as rotation of the taint values to decrease false positives. KLEAK detected more than 20 kernel information leaks in NetBSD-current and FreeBSD 11.2.

Kernel memory disclosures - also known as kernel information leaks - denote the inadvertent copying of uninitialized bytes from kernel space to user space. Such disclosed memory may contain cryptographic keys, information about the kernel memory layout, or other forms of secret data. Even though kernel memory disclosures do not allow direct exploitation of a system, they lay the ground for it.

We introduce KLEAK, a simple approach to dynamically detect kernel information leaks. Simply said, KLEAK utilizes a rudimentary form of taint tracking: it taints kernel memory with marker values, lets the data travel through the kernel and scans the buffers exchanged between the kernel and the user space for these marker values. By using compiler instrumentation and rotating the markers at regular intervals, KLEAK significantly reduces the number of false positives, and is able to yield relevant results with little effort.

Our approach is practically feasible as we prove with an implementation for the NetBSD kernel. A small performance penalty is introduced, but the system remains usable. In addition to implementing KLEAK in the NetBSD kernel, we applied our approach to FreeBSD 11.2. In total, we detected 21 previously unknown kernel memory disclosures in NetBSD-current and FreeBSD 11.2, which were fixed subsequently. As a follow-up, the projects’ developers manually audited related kernel areas and identified dozens of other kernel memory disclosures.

Notebooks let you blend code, data, and graphical visualisations to explore and share explanations. I’ll show how you can use F# in Jupyter to investigate data, train machine learning models, and visualise results.

You'll learn how to use F# and several NuGet libraries in a more interactive setting than your usual development environment. I'll talk about how we use this in our work on programming biology, and ways other people may find it useful to work with data scientists.

It's an open source project https://github.com/fsprojects/IfSharp and there are several ways people could help from connecting to more analysis tools to helping with the migration to .NET Core.

With the upcoming change from a dedicated technology called SDI towards IP. The goal is to move from dedicated boxes to pure software based broadcast. Our Toolkit can help you on your way to discover SMPTE ST 2110, AMWA interface specifications, and many more.

We've recently migrated our developer portal from a wiki-based system to Grav CMS to support Docs-As-Code. In my talk I'll share our ups and downs in this long and exciting joruney.

Legal issues are at the heart of FOSS, and lawyers play an important role in the creation and adoption of free software. Around the world, legal practice is constrained and governed by different rules outlining who lawyers can represent, how they can interact with their clients, the nature of advice they can give, how they deal with conflicts of interest and what information they must keep confidential. This panel will talk about how legal ethics plays out specifically for free software.

In this talk, I address the direct value or user research for small teams. It illustrates how much money, developmental effort and time a remote team had lost without a proper research process. In 2013 I was working on an RSS-reader: a personal project that quickly grew to six digits daily active users. Five years later, I look back, reflecting on the research-related mistakes and outlining what lightweight and budget-friendly methods could have flipped the table, including approaches to planning, organising and running research.

The importance of following a user-centered design approach has been declared over 53 million times on the internet, according to Google Search results. However, in practice, small teams may not have the resources, and often lack a dedicated researcher or the luxury of proper budgets, so the research becomes a lesser priority compared to the delivery side of projects. This creates sets of problems, where teams are losing money, waste limited developmental efforts and are often unable to evaluate their work on a larger scale.

In 2013 I was working on an RSS-reader: a personal project that quickly grew to six digits daily active users. We did not follow a proper research process and because of that made some seriously bad mistakes and decisions. This talk lists the core ones and outlines what lightweight and budget-friendly methods could have dramatically change the situation, including approaches and advice on planning, organising, running and presenting research along with the advice for developers and engineers. Since the topic of "Should designers code" has been hotly debated in the past couple of years, maybe it is time for discussion around "Should developers research" and arguments for (and against!) non-UX-people being involved in traditional UX activities.

This talk covers: - The direct value of (not) doing research - Planning, organising and running lightweight discovery and evaluation activities - Introducing research to non-UX people

This talk compares the approaches using a simple Go app, once implemented as containerized microservices and once as a serverless app and discusses advantages and limitations of each approach.

Increasingly, we find deployments of Go in either a containerized setup (read: Kubernetes) or serverless (think: AWS Lambda). This talk compares the approaches using a simple Go app, once implemented as containerized microservices and once as a serverless app and discusses advantages and limitations of each approach. We will review the workflow end-to-end, and touch on topics like defining domain boundaries, communication, sharing state, observability, and costs, both in terms of learning curve and actual money. Parts of the app will be demoed live.

In this talk I want to open a window into the wonderful world of "alternative" programming languages for RISC-V. What can you get by looking beyond C/C++.

So I will start with a quick introduction to the Ada and SPARK languages, the benefits, the hurdles. I will also present an overview of the applications and domains where they shine, when failure is not an option.

I will then do a short getting started session and provide all the details for you to start RISC-V programming with Ada/SPARK on different platforms (QEMU, HiFive1, FPGAs with PicoRV32).

At the end of the talk, I will give my view of the RISC-V architecture and community from the perspective of an alternative languages developer. I will cover the good points, the risks, and provide some ideas on how the RISC-V can keep the door open.

Mgmt is a real-time automation tool that is fast and safe. As we get closer to a 0.1 release that we'll recommend as "production ready", we'll look at the last remaining features that we're aiming to land by then. We'll explain and demo the import and module system, classes, and native functions.

We'll also show some exciting real-time demos that include scheduling, finite state machines, and remote execution.

Mgmt is a real-time automation tool that is fast and safe. As we get closer to a 0.1 release that we'll recommend as "production ready", we'll look at the last remaining features that we're aiming to land by then. We'll explain and demo the import and module system, classes, and native functions.

We'll also show some exciting real-time demos that include scheduling, finite state machines, and remote execution.

A number of blog posts on the subject are available: https://purpleidea.com/tags/mgmtconfig/ Attendees are encouraged to read some before the talk if they want a preview!

The presentation describes how Ada Database Objects helps in connecting to an SQLite/MySQL/PostgreSQL database from Ada. It explains how by mapping SQL tables in Ada records, it simplifies saving and updating database records and makes the application more safe and reliable. The presentation will briefly describe the Ada code generator (Dynamo) that is behind this.

As we know LibreOffice is an editor built around the feature set of ODF standard. When it comes to interoperability with other formats, notably OOXML, this causes another interesting source of problems: there are features available in the editor that might not be available in the counterpart product and consequently neither in OOXML format. The result might be loss of work time: the user assumes if she saves her carefully crafted document in OOXML it will be retained. In some unlucky cases this might not be true because of differences between the LO feature set and the file format preferred by the user or her peers.

My proposed solution to this is a small, simple and gradually extensible one: let's offer a configuration key that might be turned on by system administrators and this in turn would disable elements of the LibreOffice UI that offer features not available in the OOXML file format, or set different defaults in certain situations.

Now that Kubevirt, a converged infrastructure that brings virtualization on top of Kubernetes came into the world, it’s time to take a look on the monitoring aspects of this solution. This talk will go through some of the popular monitoring solutions and integrations that exist for Kubernetes, a sneak peak of how monitoring is done for Virtual machines on oVirt's open-source distributed virtualization solution and how could it be applied on Kubevirt. Attendees with Kubernetes experience could learn more on monitoring solutions for both Kubernetes and virtualization.

The 'complex camera' user-space library is a fairly new and hot topic in the Linux kernel video community. The issue is debated and targets a real technical debt of Linux systems. Device producers have been tackling this with in-house solutions that proved not to scale once brought in the open space, so a generic solution is now required to address the issue.

The Linux kernel video input subsystem and its APIs changed greatly in the last years to keep up with the increasing complexity and processing power embedded in modern SoCs. Namely, the biggest game-changing feature introduced already 5 years ago is the media controller subsystem and its pad oriented APIs, that allows composing pipelines of processing blocks to model the acquisition and re-processing of video and images.

While most of the media subsystem drivers in mainline Linux have been ported to fully support media-controller, the real missing component is now user space support to automate setting up and controlling the image processing pipelines.

The Video4Linux community is now tackling the issue by implementing support for "complex camera" systems by providing a user space library that aims to support the most recent use cases represented by mobile consumer devices and high end laptops.

This talks provides an overview of modern media-controller capable video device drivers, their userspace APIs and the challenges the currently in-development "libcamera" library has to face.

It also aims to provide to both driver and application developers an overview of the most modern implementation of the Linux video input stack architecture, that will likely be found in most system in next years.

Step by step, internet as we know it is currently being limited, censored and monitored. To prevent and fight against this, there are associations, activists and such... and one of the proposals is... IPFS protocol. IPFS is, as the official website describes "peer-to-peer hypermedia protocol to make the web faster, safer, and more open". It wants to offer a distributed alternative protocol, making it more resilient which is handy in case of developing countries, for example.

In this speech I'd love to introduce the reasons that brought internet community to care about distributed internet, what is IPFS and how to easily setup and start using it on linux terminal and web interface.

We are in the late 80's, internet is very exciting, everyone want to have a webpage... Communication has changed, and we are going into a new lifestyle, in which we can be anonymous, there are no walls between users and knowledge is open. But... uh-oh, some countries are not very happy with this statements... Internet begins to have such importance, it shapes society. If you where an ambitious company or country, wouldn't you think... Who has internet control has society influence, right?

This was actually predicted by some computer scientist and technology related persons back then, and that's why associations such as the Electronic Frontier Foundation were created. As internet has evolved since then, it has been limited and censored, as I already describe above. Tim Berners Lee (world wide web) already expressed the need of a new way of understanding the internet, more specifically, a distributed way of doing it. One of the most ambitious projects for decentralize the internet is IPFS, a distributed protocol that can be used from the terminal and has a web interface, very user-friendly.

I aim to show the basic commands, explaining the close-future options that this protocol give us, and explain why is this important.

The Netmap framework provides a simple and efficient user-space API for direct access to Ethernet NICs and other fast software interfaces (e.g., VALE switches, pipes and monitors). Because of its flexibility, performance and ease of use, Netmap is an attractive solution to implement high-speed portable Virtual Network Functions. This talk shows how to write packet processing applications using the Netmap API, and run them inside QEMU VMs, over passed-through Netmap interfaces. With Netmap, applications running in two VMs or containers can exchange up to 20-30 Mpps (per-core) at minimum packet size.

The need for an alternative mechanism and APIs for network I/O has been recognized by several O.S. bypass projects (DPDK, PF RING), and comes from the performance limitations of the traditional socket API (and the associated O.S. implementation) in terms of maximum packet rate. Using a traditional socket API a single processor core is not able to send or receive more than 1-2 million packets per second (Mpps) at minimum packet size (60 bytes), despite of much faster modern NICs which support 10-100 Mpps. These limitations are largely due to per-packet size-independent costs: system call, packet copy across user/kernel boundary, VFS layer overheads, dynamic (de)allocation of packet metadata (e.g. sk_buff on Linux), NIC register access and interrupts. Moreover, moving networking to userspace facilitates experimentation and improves portability. The bypass solutions overcome these limitations by pre-allocating packet buffers, mapping those buffers in the application address space and allowing applications to send and receive multiple packets using a single operation (e.g. a system call or a NIC register access). They also use simple packet representation structures optimized for raw packet I/O rather than for full-fledged protocol stack. When combined together, these techniques allow user-space applications to send/receive tens of millions of packets per second, saturating the NIC capacity even with short packets. Exploring Netmap is a good introduction to these topics, common to all frameworks. However, Netmap brings some additional benefits that are not found elsewhere: it does not force applications to resort to busy-polling, it protects devices from uncontrolled user-space access, and it introduces a common API which can also be used for fast VM networking and Inter-Process Communication. Netmap is available on both Linux and FreeBSD.

The Netmap framework has evolved significantly from its inception as a user-space packet I/O interface to NIC hardware in 2011. It is now a flexible network I/O tool that supports many backends (in addition to NICs) and virtualized environments, accessible with the same API. The VALE programmable switch (part of Netmap) acts as a virtual switch for Virtual Machines (VMs) and physical NICs, supporting hundreds of virtual ports and over 20 Mpps per-core between its ports. Netmap pipes are point-to-point virtual links that connect processes or VMs at over 40 Mpps, useful for service function chaining. Netmap as a fast network backend has been integrated into hypervisors like QEMU, Bhyve and VirtualBox. Accelerated network I/O is also possible for lightweight virtualization (containers) by means of native support for Linux veth devices (over 40 Mpps). Finally, a virtual pass-through device allows any Netmap interface (e.g. a VALE port, NIC or pipe endpoint) to be safely exposed inside a VM, enabling unprecedented packet-rates (20-40 Mpps) between VMs.

These Netmap features constitute the datapath building blocks for Network Function Virtualization (NFV) deployments. We are not aware of other technologies that allow applications running in two VMs or containers to exchange up to 20-30 Mpps at minimum packet size. With such powerful I/O capabilities, we believe Netmap is the preferred candidate to implement NFV applications such as load balancers, Intrusion Detection Systems, firewalls, etc.

What are Common Table Expressions (CTEs) and Window Functions? Why do you need them? How to use them?

Correlated subselects are a pain, but your software needs them? You still could need recursive queries? You want an easy way for finding lagging or leading rows? The keywords are Common Table Expressions (CTE) and Window Functions. Finally, both, MariaDB and MySQL support them. After explaining functionality and use cases, the talk also will show the ease of use.

We've got rid of GOTO and the spaghetti code it leads to in 1970's. However, we are encoutering very much the same problems when writing concurrent code even now, 50 years later. Programmers are still stuck deep in the callback hell or state machine hell. Concurrent code still looks like spaghetti. And while Go language provided a tool to write unspaghettified concurrent code to the masses, by no way are all the pieces of the puzzle in place.

This talk focuses on what's missing. It explains where the current mainstream paradigms break the vital principles of encapsulation, separation of concerns and correspondence between layout of the code and the execution flow.

It introduces a bunch of current approaches covered by the umbrella term of "structured concurrency" that attempt to solve these problems.

The talk may be interesting to anyone who has to deal with concurrency, irrespective of the language they are using.

Besides looking at the problems at hand, the talk will show examples of structured concurrency in Python (Trio) and C (libdill).

Let's see the state of WebAssembly technology in 2019, their progress and browser support

"WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable target for compilation of high-level languages like C/C++/Rust, enabling deployment on the web for client and server applications." - This is the description of Webassebly from official website. In this talk we'll see the progress of this technology during last year, starting from the state of the art in early 2018 until early 2019.

A typical result in Numerical Analysis is an algorithm to solve a mathematical problem. The main ingredients are the precise statement of the problem, an algorithm to solve it, and an assessment of the errors. From algorithm, there is a long journey to a program: the method needs to be more user-friendly (handling of error cases, etc.), has to be implemented in a programming language, and tested. The resulting program is not only a practical product, but also a very precise description of the algorithm. If the reader is a computer, nothing is left to interpretation as long as the translator is correct. In my talk, I would like to introduce an effort to preserve mathematical software: the histoRicalg project, and summarize some of its results.

In two decades from 1970 to 1990, there was an upsurge in the writing and publication of mathematical software. Much of this has been collected in subroutine libraries or published in print or in machine readable form. Traditionally, scientific results are published in journals, and journal papers are archived in libraries. However, as programs grew larger, they were no longer printed with the papers, but sent to interested readers on tape, diskettes, or other forms of data storage.

The knowledge accumulated in these codes is extensive and valuable. Its preservation, however, is more difficult than that of papers. Storage technologies come and go, programming languages come into fashion, then become forgotten. To preserve the algorithms, one needs to constantly copy their source code from old computers to newer ones and preserve the tools needed to compile them.

In this poster, I plan to introduce one effort to preserve mathematical codes: the histoRicalg project. Its primary objective is to find, document, and preserve the originals of the numerical codes that have found their way into the R statistical programming system. In particular, I will summarize my experience with attempts to run the originals of these codes on a modern Linux PC.

PRESERVING NUMERICAL ALGORITHMS

A typical result in Numerical Analysis is an algorithm to solve a mathematical problem. The main ingredients are the precise statement of the problem, an algorithm to solve it, and an assessment of the errors. From algorithm, there is a long journey to a program: the method needs to be more user-friendly (handling of error cases, etc.), has to be implemented in a programming language, and tested. The resulting program is not only a practical product, but also a very precise description of the algorithm. If the reader is a computer, nothing is left to interpretation as long as the translator is correct.

In two decades from 1970 to 1990, there was an upsurge in the writing and publication of mathematical software. Much of this has been collected in subroutine libraries or published in print or in machine readable form. Traditionally, scientific results are published in journals, and journal papers are archived in libraries. However, as programs grew larger, they were no longer printed with the papers, but sent to interested readers on tape, diskettes, or other forms of data storage.

The knowledge accumulated in these codes is extensive and valuable. Its preservation, however, is more difficult than that of papers. Storage technologies come and go, programming languages come into fashion, then become forgotten. To preserve the algorithms, one needs to constantly copy their source code from old computers to newer ones and preserve the tools needed to compile them.

I plan to introduce one effort to preserve mathematical codes: the histoRicalg project. Its primary objective is to find, document, and preserve the originals of the numerical codes that have found their way into the R statistical programming system. In particular, I will summarize my experience with attempts to run the originals of these codes on a modern Linux PC.

Present status:

• SLATEC codes: Fortran 77. Modifications only needed for machine dependent parts; code is well preserved. LINPACK and EISPACK parts are largely superseded by LAPACK.
• PORT Library: Bell Labs has changed owners and the web site is gone. Fortran 77. What code we have runs without changes. Contains an interesting collection of optimization algorithms.
• CMLIB: large overlap with SLATEC. Fortran 77. So far UNCMIN has been tested.
• NSWC: large overlap with SLATEC. Fortran 77. Needs changes in machine dependent parts. Large collection of special functions routines. So far, I have checked machine parameters: integer parameters match x86_64-linux-gnu.
• NUMAL: one of the early attempts at a mathematical software collection. Algol 60. Needs a translator to run. I have created Ubuntu packages for two translators (MARST and JFF-ALGOL).
• CALGO: Fortran 77 and Algol 60 parts, not all available in machine readable form. Prof. Tim Hopkins, ACM Algorithms Editor, has informed us of translations to Fortran 90 and extensive testing in progress.

Language translator status

• Fortran 77 is "too big to fail": it is well supported after 40 years (gfortran, f2c)
• Algol 60 is far less so, but a translator to C is available
• Algol 68 and Algol W also have translators
• BASIC, Pascal are not as old and there are workable tools
• Many less widely used languages far more problematic (APL, PL/I, ...)

Case study: UNCMIN

• Minimization code used, e.g., in R as function nlm()
• Well known: Kahaner Moler Nash (1989) has a subset code, while CMLIB has a version of the full original (code). R apparently has this code translated to C via f2c and hand editing.
• Recent bug reports have appeared for R. Is there a bug in the original?

Outlook and difficulties

• An additional issue: abandonware. What is to be done if the code is copyrighted, but we can not contact the author anymore?
• Preservation: fix code that violates (sometimes newer) standards
• Are there bugs? If so, were they present in the original version? And which version is the original?

Consider a Java application in a private banking system. A new network administrator is hired, and while going around, he notices that the app is making network calls to an unknown external endpoint. After some investigation, it’s found that this app has been sending for years confidential data to a competitor (or a state, or hackers, whatever). This is awkward. Especially since it could have been avoided.

Code reviews are good to improve the hardening of an application, but what if the malicious code was planted purposely? Some code buried in a commit could extract code from binary content, compile it on the fly, and then execute the code in the same JVM run… By default, the JVM is not secured! Securing the JVM for a non-trivial application is complex and time-consuming but the risks of not securing it could be disastrous. In this talk, I’ll show some of the things you could do in an unsecured JVM. I’ll also explain the basics of securing it, and finally demo a working process on how to do it.

JanusGraph provides access to persisted graph data in a way that is scalable in data size and graph traversal length. Graphs become more valuable if data from multiple sources is ingested, but in general not all users will be authorized to access all data in the graph, given privacy laws on personal data and corporate policies. Since it is not practical to maintain separate copies of large graphs for the different authorization groups, a technical solution for access control is required. This presentation deals with this issue and discusses techniques to provide access to graph data under heterogeneous confidentiality regimes. In particular, an add-on TinkerPop API is presented that provides an abstration to the required filtering and supports the auditing of gremlin queries for validity.

No description provided yet.

There are plenty of tools that can analyze data in many ways, but just a few of them try to visualize this data in new ways. This is the aim of VBoard, a 100% open source web application that allows building visualizations and dashboards in 3D and VR using A-Frame as its core render library. The data is retrieved in real time using a ElasticSearch, and VBoard saves its objects (visualizations, dashboards) in it.

In this talk I will show the functionality of VBoard, starting with a general overview, its installation steps and a simple step by step user guide. All of this in order to build a 3D and VR dashboard from scratch. To finish, I will show examples of what kind of visualization/dashboard you can build with VBoard using data retrieved with GrimoreLab related to open source projects (e.g., commits, usernames, repositories, etc.).

The goal of VBoard is to have a complex data visualization system in a 3D and VR environment. It started as my master's thesis and finally became a web application that uses A-Frame as the visualization render engine and ElasticSearch as a database and search engine. Specifically, VBoard rests on A-FrameDC to show these data visualizations, A-FrameDC is a JavaScript library to create different kind of data visualizations based on A-Frame. A-FrameDC extends A-Frame, encapsulating it in another library so that the construction of 3D elements is focused on data visualization graphics and it allows the creation and interaction with them in a simple way. This library allows the creation of different kinds of charts, from the simplest 2D charts like pies to 3D charts like bubbles. VBoard takes advantage of A-FrameDC using it in a web interface, making the visualization building process easy and scalable, permitting also the persistence of the objects (visualization and dashboards) saving it in the same ElasticSearch that it does the queries.

The talk will show how to create visualization and dashboards with VBoard. I will start by explaining how to install it in a few steps. I will show how to import open source project data (e.g., commits, usernames, repositories, organizations, etc.) to ElasticSearch using GrimoireLab in order to build the visualization with it. Then, I will build visualizations from scratch, showing its features and usability. You will see how simple it is to create a 3D and VR dashboard that relates useful data like the relation of users with repositories, organizations, etc.

Building end-to-end applications is not easy, or at the very least, it comes with its own unique set of challenges.

There are the often talked about challenges, like making sure you use battle tested encryption primitives and use them correctly, and striking the balance between security and usability. Unfortunately, there are many more challenges that are not often talked about, like the significantly decreased development speed due to all the code being implemented on the client side, the increased difficulty and complexity in upgrading the protocol and many others.

In this talk Tom will use EteSync as an example for a secure application to show some of the more interesting challenges he faced while creating it, and new challenges that he encountered as the user-base grew and the protocol evolved. Tom will also cover some of the issues that affect EteSync today, how they will be addressed in the future, where EteSync is going, and what's currently holding it back. By the end of this talk, attendees will be made familiar with some of the unique challenges that come with building end-to-end encrypted applications and some alternatives for solving them.

Audience:

• People interested in the inner workings of EteSync
• Developers interested in, or actively designing secure applications and protocols
• People interested in the future of the EteSync

3 lightning talks about news and the most important experiences of the various LibreOffice developments made for migration projects in public administration and education, based on my recent presentations of LiboCon, Tirana, and our newer results.

Building a LibreOffice development team: We have found and filed more than three hundred bugs during the biggest LibreOffice migration project of Hungary. Our help desk service couldn't handle these efficiently using half measures and workarounds, so we started to build a small LibreOffice development team focusing on the most important OOXML compatibility and other migration problems. After three month learning and trial period, we summarize our results and failures for LibreOffice community.

LibreOffice language technology – news and best practices: This lightning talk shows new and improved language technologies of LibreOffice and their usage: new features of Hunspell spell checker (better handling of words written separately or with special orthography, faster suggestions, etc.), “Grammar by” spell checking for default technical dictionaries, Numbertext and NatNum12 number modifier for default date and other formats fulfilling special language needs, and exemplary developments for example for German (hyphenation using compound feature of libhyphen) and Hungarian (fields with automatic article selection; spell checking of word with special word breaking, for example, recognizing the parenthesized word forms, like “us(ag)e”).

LibreOffice and eTwinning: LibreLogo in schools and teacher training programs: LibreLogo, integrated Logo extension of LibreOffice is based on strong practical and educational principles. After 4 years of research period, lead by Andreas Formiconi, University of Florence advocates LibreLogo usage in eTwinning program, community of European schools. This short presentation summarize the research results and recent and planned improvements of LibreLogo.

gRPC is an open source remote procedure call framework built on HTTP/2 that provides an easy way to create high performance, scalable APIs in a multitude of programming languages.

In this talk we’ll describe what grPC is, how we it came to be, and compare it to some other alternatives. We’ll talk about the pros and cons and hopefully convince you to take a closer look at it and add it to your toolbox.

Best of all we’ll walk through an example of how to build a gRPC based application using gRPC, Protobufs and Go! We’ll even take a look at how easy it is to add a client using another programming language.

The whole idea of virtualization is to utilize resources as heaviliy as possible. oVirt, an open- source virtualization solution, comes with several techniques, that require every VM to actually fight for each byte it needs, thus keeping disk usage as small as possible. oVirt uses different types of thin provisioning, data compression and data deduplication, to improve disk space utilization.

Perl 6 grammars are a great way to describe the grammar and implement an interpreter or a compiler of DSL or a programming language. In this talk, I will demonstrate how you can do it.

During the talk, we will create an interpreter for a tiny programming language. The engine behind the implementation will be the so-called Grammars that are available in today's Perl 6. We will create the full language specification and describe all the actions it needs to do to execute the program.

The great part is that you no longer need to split your language implementation in traditional phases: lexer, parser, etc.. Neither you need a compiler of compilers to process the formal grammar rules and emit the lexer/parse code that you will later use in your compiler. All you need is just to write some Perl 6 code.

You even don't need to be a specialist in compilers or learn numerous tools like bison etc. to create your own language in a few hours.

We will show a new Trained Compression generic plug-in, which can leverage prior information about the data to be transmitted for reducing further raw compressed streams. We will also present a pick-and-choose technique feature called "Preselection" for improving the Zip archiving process.

The Zip-Ada library has met over the years the needs of several professional users who need the file archiving features, or the data compression features to reduce storage and shorten transmission times. We will show the evolution of this full-Ada portable library and the advantages of using it.

The next generation of research infrastructure and large scale scientific instruments will face new magnitudes of data. StackHPC have been working with Cambridge University on the Square Kilometre Array (SKA) radio telescope project (in collaboration with both CERN and Cambridge University) to build a performance prototype using OpenSource tools such as OpenStack and Kubernetes.

One of the biggest challenges is building storage fast enough to deal with the expected 4Tb/s Read and 0.5 Tb/s Write, yet flexible enough to deal with the expected variety of workloads being run on the system. This has involved much collaboration with CERN given the shared challenges posed by the High-Luminosity LHC upgrade.

The second aspect is making a system that keep up with the ever changing nature of the workloads running on the system. Key ideas from this project are being deployed in production on Cambridge University's Cumulus supercomputer (#87 in the Nov18 top500 https://www.top500.org/system/179577). We explore how this move away from a single Slurm cluster is helping meet a broader range of research computing needs.

How can we be sure of the continuous configuration management proper operation? How to expose factual topic-related reports to dev, sec, managers, customers...?

We believe that, in order to deliver the full business and collaboration value of continuous configuration management, the solution needs to go further than simply applying policies - it must ensure configuration reliability; prove historized application and status; share it to other teams; notify of any drift with a relevant context.

This talk will present why and how we should be concerned about transmitting factual measures on infrastructure management to all parties involved. We will also guide you through the journey to include a full-fledged reporting feature in a configuration management solution.

Early in 2018 I responded to a call for help published in the Open Source Design jobs board (https://opensourcedesign.net/jobs/). It was from the maintainer of something called SReview (https://github.com/yoe/sreview), which happens to be the software FOSDEM uses to capture, post-process and publish the videos of all the talks at the conference.

Over the past 10 months we redesigned the SReview interface in a user-centred, collaborative, iterative and open way. This talk explains how we went about it. Using a model of the "ideal" design process as a reference, we'll show where we deviated from it and why. The moral of the story? There is no best way of doing design. The best way of doing design is the way that suits your project.

Early in 2018 I responded to a call for help published in the Open Source Design jobs board (https://opensourcedesign.net/jobs/). It was from the maintainer of something called SReview (https://github.com/yoe/sreview), which happens to be the software FOSDEM uses to capture, post-process and publish the videos of all the talks at the conference.

SReview takes a rather ingenious approach to the problem of how to review presentation videos before publication. Instead of the small video team doing all the work, which would take ages, they crowdsource the task, by asking the speakers themselves to review their own presentations. Speakers get an early preview of the video - something they appreciate -, and the FOSDEM video team gets the job done faster. Everybody wins.

There was only one small problem: the interface speakers had to use to review presentation videos was not working. Speakers kept making mistakes in the process, which caused a lot of extra work for the FOSDEM video team.

Over the past 10 months we redesigned the interface in a user-centred, collaborative, iterative and open way. This talk explains how we went about it. Using a model of the "ideal" design process as a reference, we'll show where we deviated from it and why.

The moral of the story? There is no best way of doing design. The best way of doing design is the way that suits your project.

Modern cloud applications consist of many moving parts, so they are hard to manage without employing Infrastructure-as-Code approach.

Traditionally, tools like CloudFormation, ARM templates and Terraform employ text-based templates, which tend to be verbose and hard to create and reuse.

What if instead of configuration files you could just use Typescript? Meet Pulumi—an open-source library which brings types, components, conditionals, and much more to your cloud infrastructure definition.

At the beginning of 2018, the French Government reached out to Matrix.org to discuss the idea of creating an entirely open source, standards-based encrypted messaging app as the official means of instant messaging and VoIP communication across the government; replacing adhoc usage of centralised proprietary services such as Telegram and WhatsApp. As of summer 2018, their app exists (a public fork of Riot.im), and there is now a massive federation of Matrix servers deployed throughout the government serving up to 5.5M users, spanning over 30 clusters, letting each ministry run and admin their own operationally independent deployment. In this talk we'll tell the adventure of rolling out FOSS communications at this scale, and give a tour of the architecture and all the work that's gone into Matrix along the way to reach a 1.0 capable of powering government-grade communication.

Matrix is an open source project that defines a protocol for secure, decentralised real-time communication - providing simple HTTP+JSON APIs for sending and receiving instant messages, VoIP calls, file transfers, and any other arbitrary realtime data. In this talk we'll tell the tale of how the French Government has deployed Matrix at massive scale, show off their app and its capabilities, and dive into all the challenges and solutions which came up along the way. Particularly, we'll cover what was needed to finalise Matrix's end-to-end encryption such that it can be turned on by default for all conversations; designing whole new extensions to Matrix to support content-scanning of E2E encrypted attachments, and the pleasures of high-availability clustering and management of Matrix server farms by Ansible.

Meanwhile, Matrix itself is rushing towards a 1.0 release (as of Oct 2018) - defining stable releases of the spec across all API surfaces; defining the long-term open governance process for Matrix; iterating on the room state merge resolution protocol which lies at the core of Matrix's decentralisation; and massive amounts of performance work: reducing disk space by 10x thanks to improved state compression; switching from O(N) to O(1) state resolution via memoization; reducing sync sizes and client RAM by 3-5x via lazy-loading members; saving 2-3x RAM in Synapse by migrating from Python 2 to Python 3 etc. We'll give a tour of Matrix 1.0, and talk about what comes next!

This presentation will explain RIST (Reliable Internet Stream Transport), a new protocol for professional video transport that is evolutionary. It is a protocol designed to allow for packet retransmissions between broadcast equipment, something which in the past had been vendor specific. Unusually for professional standards, it has a public specification and thus has already been implemented in a number of open source projects. This talk will took about the good parts and the bad parts as well as comparing it with traditional transport protocols such as TCP.

The past year the focus in this kernel subsystem was on bug fixing, new drivers and improved CEC debugging support. This presentation gives an overview of the current status and future work.

This talk is a replacement for the cancelled talk by intel's Manasi Navare "Display Stream Compression: More pixels, faster, over DisplayPort", as intel decided not to approve travel for Manasi.

FreeBSD Graphics - what is it, and how does it work?

In this presentation I will talk about the FreeBSD Graphics effort and the team behind it. I will work my way through the graphics stack, starting with kernel drivers and end with the X server, talking about the various components along the way.

In this presentation I will talk about the FreeBSD Graphics effort and the team behind it.

I will give an overview of the various components that make up the FreeBSD graphics stack, starting with the kernel drivers and subsystem, and then work my way through the stack. I will talk a bit about Mesa, the X server and other software in the FreeBSD graphics ecosystem.

I will also talk a bit about the team behind it, what is going on, and where we are going, as well as challenges working with and porting the graphics software.

This talk is intended to give a broad overview of the FreeBSD Graphics stack and the team working on it. I will not go into too much technical details on each part of the Graphics stack, instead focusing on the big picture.

ONOS is an open source project, written in Java that aims to deliver a software-defined networking (SDN) OS focusing on scalability, high availability, and high performance. The session will go over the ONOS modular architecture, its main tenets, use cases, and applications. It will describe the APIs that enable programmability in the network, both at the control and data planes.

The talk will detail how your needs in network programmability are easily solved by new apps, REST APIs and other tools that the ONOS platform offers. ONOS has become production ready. The code undergoes strict and high-quality testing. ONOS is currently in production in data centers managing traffic on thousands of customers in mission critical networks. The talk will highlight how ONOS serves as a building block for opensource and commercial projects, such as Software enabled Broadband Access (SEBA), SONA for networking in Openstack and others. ONOS is also deployable in a kubernetes environment through docker containers. ONOS also keeps pushing the boundary of new technologies, for example enabling data plane programmability through P4 and P4Runtime and by providing support and connectivity to edge cloud deployments to better offer low-latency, personalised and secure services to the end-users.

Finally, the talk will dive into the great ONOS open-source community, its strengths and how to become part of it.

MySQL 8.0 supports SQL feature T491 LATERAL derived table, also called the "for each" loop of SQL. What is it? How does it work? How can you use it? What is it good for? Learn all about it in this talk!

Mozilla's A-Frame library makes it really easy to create WebXR experiences (XR stands for Mixed Reality, i.e. Virtual and Augmented Reality) without requiring a lot of code knowledge. VR Map builds on that and the availability of real-world data from OpenStreetMap (OSM) to demonstrate how to build a model of the real world in an WebVR environment.

The talk will describe what WebXR is, how building basic scenes with A-Frame works, and how those technologies were used together with live data from OpenStreetMap to create the "VR Map" demo that allows people to walk and "fly" through a model of the real world in a Virtual Reality scene rendered directly in a browser supporting the WebXR Device APIs, ideally Firefox, of course.

Raspberry Pi, the most popular single board computer for hobbyists and students, is an affordable and widely used platform for retrogaming. Over the years the community has created numerous cool cases, add-on boards and peripherals for optimized gaming.

In this presentation you will learn how to use cutting edge free and open source technologies such as KiCAD and OpenSCAD to create a gamepad as a Raspberry Pi HAT (Hardware Attached on Top) with device-tree fragment for mapping the keys saved in an EEPROM connected via I2C. Exact steps for setting it up and playing retro games in emulators on RetroPie and Raspbian will be provided. Furthermore we will discuss the benefits of the open source hardware and the certification program of Open Source Hardware Association (OSHWA).

The presentation is appropriate for anyone interested in low-cost retrogaming and modern free and open source software technologies. No previous experience or hardware knowledge is required. Apart from retrogaming enthusiasts, the talk is appropriate for wide range of developers, makers, and students. Hopefully, the presentation will encourage the attendees to grab the soldering iron and start prototyping retrogaming compatible hardware for fun and profit.

Raspberry Pi, the most popular single board computer for hobbyists and students, is very affordable platform and it is a popular solution for retrogaming. Nowadays modern free and open source tools allows us to develop Raspberry Pi add-on boards to improve the gaming experience. Over the years the community has already created numerous awesome hardware projects for cases, add-on bards and peripheral optimized for retrogaming. The focus will be on providing guidelines and recommendations how to use the open source EDA software KiCAD to design open source hardware gamepad as a HAT (Hardware Attached-on Top) according to requirements of the Raspberry Pi foundation as well as a simple cases for laser cutting or 3D printing with another popular open source software tool OpenSCAD. Using practical examples related to retrogaming you will understand how to create device tree binary overlay for mapping keys and how to flash it in EEPROM attached to pin 27 of 28 of the Raspberry Pi header. Exact steps for setting up and using our do-it-yourself gamepad with popular GNU/Linux distributions RetroPie and Raspbian will be provided. Last but not least we will discuss the benefits of using open source hardware and the certification of the Open Source Hardware Association (OSHWA). The presentation is appropriate for anyone interested in low-cost retrogaming and modern free and open source software technologies. No previous experience or hardware knowledge is required. Apart from retrogaming enthusiasts, the talk is appropriate for wide range fo developers, makers, and students.

RISC-V is an increasingly popular architecture for embedded systems. For such systems, compiled code density is a critical factor, particularly for deeply embedded and low power systems, where memory may be very constrained. Architectures in this space are often designed to improve code density. Thus ARM has its Thumb-2 instructions and RISC-V has its compressed instructions.

If compiler tool chains are to generate compact code, we need to be able to measure how well we are doing. In this talk I shall present measurements of code density for 32-bit RISC-V, ARM and ARC architectures using the GCC and Clang/LLVM compiler tool chains using the BEEBS benchmark suite for deeply embedded systems (http://beebs.eu/). I shall show how confounding factors (such as emulation library implementation and C run-time startup) can be eliminated from such measurements, to ensure the results are meaningful.

The purpose of this exercise is not to show that any one architecture is "best" but to provide insight which will drive compiler optimization for code density. I shall use the data to highlight areas where the RISC-V compiler tool chain can be improved, drawing on customer work carried out by Embecosm during 2018.

In this talk, we identify some well-known software verification problems, using real-world examples from open-source projects and see how we might apply some deep learning principles to address them. In the various points where we may test the Java runtime, we find candidates for deep learning. What is required? We need a problem to solve, a model that describes it, and a large amount of data to feed the neural network.

MicroPython is an implementation of Python designed to run on microcontrollers and embedded systems. These devices don’t have many resources (CPU, RAM) and so it’s important to write efficient scripts. This talk shows how to make the most of your resources in MicroPython, and has some fun demos!

MicroPython is a reimplementation of Python which is specifically designed to run on computing devices that have very few resources, such as CPU power, RAM and storage. Often when you write scripts in MicroPython you want to make the most of your available resources, and have code run as fast as possible (faster code usually saves power, which is important when running from a battery!) and there are certain ways of writing MicroPython code that are more efficient than others. In this talk I will go over the tricks and techniques for writing fast and efficient Python code in MicroPython. The talk will also include some hardware demos to show off these techniques.

Experience with wisp: 5 years with fewer parens

What changed, what evolved, best practices, usage for a lecture, and why wisp aka SRFI-119 is completed as a language (though not in tooling or documentation).

Ansible is one of the fastest growing projects in the history of opensource. It is simple, flexible and powerful, and there is a huge community behind it. Ansible is capable of automate systems, storage and of course, networking. However, Ansible is stateless, and from the network engineer standpoint, a stateful view of the network topology is needed. There is where OpenDaylight joins the game. As a proper opensource SDN controller and network platform, OpenDaylight provides the translation of bussiness APIs into resource APIs, and Ansible networking performs its magic in the network.

In this talk, we will go over a high lever overview of what is OpenDaylight. We will learn about its architecture and how it works and what we can do with it. Moreover, we will explain how Ansible networking is changing the game for network operators due to its simplicity and flexibility. Both of this components can create an automation engine for network devices with all the benefits of an SDN controller such a centralized control plane, programmability of your network and that holistic approach that networking engineers love.

One more thing... there will be a live demo! We will demonstrate the ability to create an L3VPN in a typical telco service provider network with heterogeneous hardware, using the same interfaces from the user standpoint. This demo is using only opensource projects such OpenDaylight, Ansible, Skydive, etc. If you are interested in future network management, come and enjoy!

Open source tools such as QuTiP - The Quantum Toolbox in Python are playing a big part in facilitating research in quantum technologies in both academia and the industry. Such tools provide the users with the software resources to model, simulate and study various quantum effects easily. QuTiP goes beyond the simulation of quantum circuits and facilitates the simulation of the physics of quantum devices. In this talk, I will take the example of some new developments in QuTiP to show the ease with which one simulate open quantum systems as well as contribute to the development of such software tools. We will discuss various parts of collaborative code development using Git, and possible optimizations of calculations. The talk will be an end-to-end discussion of how to collaborate, develop and distribute your own open-source tools for the study of quantum systems.

A major challenge to developing quantum computing is modeling the quantum systems themselves which are used to build quantum devices - superconducting circuits, ion traps, spin qubits, photonics. In addition to simulating quantum circuits and algorithms, simulating quantum physics itself is a challenging task and if we are to harness the power of quantum computing, we need to model quantum systems better and study the interactions of a quantum system with the environment and the effect of noise.

QuTiP allows the user to simulate several quantum phenomena and study the effects of noise on an open quantum system. The open-source nature allows anyone to add and contribute code which makes it an excellent place to showcase new simulation techniques and quantum effects emerging from a research project. This also enables reproducibility and it can accelerate further study and research without the need to spend weeks reproducing previous results.

I will introduce QuTiP and discuss several examples on how to use the tool. The examples will range from generating topological circuit descriptions from arbitrary quantum circuits to simulations of spin ensembles to simulating spin-boson models with strong and ultrastrong coupling.

1. Introduction
2. Open source projects for quantum computing and quantum simulations - a brief discussion on python based tools.
3. Beyond quantum circuits: simulating quantum physics with QuTiP.
4. Examples and latest additions to QuTiP
5. Contributing your own code to open source projects.
6. Conclusions

The goal of this talk is to guide you through the integration of pre-trained models into a Go app. From A to Z, we will build an AI image search with Go and Tensorflow.

AI is on everybody's lips nowadays. Every company wants to bring it to its customers. Google, Facebook, Microsoft and more are racing against each other with research papers and open-source frameworks. From a developer point-of-view, it has never been so easy to access so powerful AI engines. The goal of this talk is to guide you through the integration of pre-trained models into a Go app. From A to Z, we will build an AI image search with Go and Tensorflow.

When writing GL applications, one needs to use APIs to bridge the rendering (as done by OpenGL, OpenGLES) with the underlying platform - X11, Wayland and others. As the technical details greatly varies across platforms, a project called Waffle was introduced in 2012.

Today Waffle is a core library, used heavily for testing GL drivers with piglit. Additionally, the library provides a simple API which allows easy integration and use of GL application across both X11 and Wayland.

For newcomers, a quick outline of the project and its usecase will be provided. Then we'll walk through the project evolution - from platforms supported, feature set and developer base. The main part of the talk will focus on the work done to improve the quality of the project. The CI that was recently deployed will be presented, static analysis tools and code coverage.

Finally, we'll talk about the outstanding "issues" of the projects - from missing features, additional testing, tooling required and everything else that is preventing people from using the project.

There had been several changes since lately around the database drivers of LibreOffice. The drivers, which are used to establish connection between various database-management systems and LibreOffice, allow us to customize Base to our needs. I am going to talk about the improvements around database drivers such as upgrading the Firebird driver and creating a migration suite. Although the majority of the talk will be about improvements around the mysql connector.

For everyone who doesn’t know what exactly we do, this is a short intro to our collective: We work to raise the profile of good design in open source software, and connect developers & designers to make it happen.

We run an Open Source Design community forum, organize design tracks at well-known events like FOSDEM (hello 🙋), FOSSASIA and OpenTechSummit, have a job board to get designers involved, provide open design resources to developers & designers, and more.

We will also take our GROUP PHOTO during this session! 😊

A few of our activities from last year include:

👩‍💻 Lots and lots of posts on our Open Source Design job board! https://opensourcedesign.net/jobs/ 2️⃣ Organization of our second Open Source Design Summit in Tirana! https://opencollective.com/opensourcedesign/events/open-source-design-summit-2018-371ev 💸 Sponsored by Sticker Mule, Mozilla & phpList and supported by Open Technology Fund, Ura Design, Red Hat & Nextcloud 📑 More activity on our Discourse forum! https://discourse.opensourcedesign.net

Things we are working on or need to work on:

💬 Attending a bunch of events and giving talks related to Open Source Design https://discourse.opensourcedesign.net/c/events 🎨 Attendance at more mainstream design events! ⭕ Still working on becoming an Open Source Initiative affiliate https://github.com/opensourcedesign/organization/issues/53 👥 We need to do more on the meetup front: https://discourse.opensourcedesign.net/c/meetups – NYC is active, but we can improve elsewhere 💻 Another work in progress is the website, we are looking into improving the design. ;)

✨ Probably lots more we forgot to list! :)

There are lots of ideas out there about how to run a free and open source software project... but not all strategies were created equal. Sometimes governance "just happens" but more often than not, projects end up with some things that work and some that don't. Transparency, clear expectations and compassion go a long way towards helping you find people who support your vision but can still bring new ideas to the table when it comes time to talk implementation. Your project's governance should reflect your values and empower individuals to succeed within its structure.

Maintaining and scaling your project is easier when you've laid a good foundation. The community is mature enough that we can learn from what's already been done and set up new projects for success. This talk will cover some of the big red flags you'll want to avoid as well as some of the structural details that will help avoid issues later on.

There are lots of ideas out there about how to run a free and open source software project... but not all strategies were created equal. Sometimes governance "just happens" but more often than not, projects end up with some things that work and some that (really) don't. Unfortunately, by the time they regret some of the bad ideas they're baked into the project and harder to change. This talk will cover some of the big red flags you'll want to avoid as well as some of the less obvious stuff that most people discover "the hard way."

Figuring out when your idea is cohesive enough to bring people in but not so detailed that you're basically looking for clones of yourself, is a delicate dance. Transparency goes a long way towards helping you find people who support your vision but can still bring new ideas to the table when it comes time to talk implementation. Laying down a few rules or sharing some expectations early on can help you avoid a world of hurt and confusion later on. And of course, there are a few nitty gritty details (like licensing and naming) that are worth paying a little bit of special attention to in the beginning.

Maintaining and scaling your project is easier when you've laid a good foundation. Join me for whirlwind tour of what not to do, what to do instead and maybe what you can do to fix what you've already done. The FOSS community has more than enough good, bad and ugly governance stories that you should at least make be able your own brand new mistakes.

CUDA has gained popularity as the programming language for GPUs.

OpenCV remains the most popular library for computer vision.

The aim of the talk is to introduce people to harness both the technologies to build high performance models for image and video processing, by using the simple problem of detecting scene changes in a video.

Detecting scene changes in videos using CUDA and OpenCV.

CUDA is a parallel computing platform and application programming interface (API) model created by Nvidia. It allows software developers and software engineers to use a CUDA-enabled graphics processing unit (GPU) for GPGPU (General-Purpose computing on Graphics Processing Units).

OpenCV stands for Open Source Computer Vision Library. It has C++, python and Java interfaces.

The scene change detection problem is can be defined formally as - given two frames, do they belong to the same scene, or different scenes? The content-aware scene change detection finds all areas in a video where the difference between two subsequent frames exceeds a threshold value. This allows to detect cuts between scenes.

The proposed algorithm has the following steps - * Decode the video. * For each frame -

       * Convert the frame to HSV colour space.
       * For each channel, find the average pixel by pixel difference with the previous frame
       * Average the difference over the number of channels.
       * If greater than a given threshold declare the frame as a scene change

The pixel-by-pixel operation of each channel can be optimised to execute in parallel. This can be achieved using CUDA.

The simple algorithm above can be optimised to execute on a GPU and achieve 10x improvements in speed.

All the code is written in C++

Some years ago we started to compile some bits of the Xamarin.Forms Xaml directly into IL. It’s now fully turned on into our templates, and on par with the runtime Xaml loader. In this short talk you’ll learn about the story that got us there, about some of the internal cooking of Xamarin.Forms, and what our plans are for that Xaml compiler.

What if you could use the same tooling to interact with libvirt, kubevirt, gcp, aws ovirt or openstack ? In this talk, I will present kcli, the tool I initially wrote to ease my work on libvirt and which evolved into a multiprovider abstraction tool We will detail installation, typical workflow and advanced features I use every day.

The GDPR (and some local regulations) have created a right to data portability. It looks like a good thing but it probably isn't, as it seems to lead to the future DTP (https://datatransferproject.dev/) from our beloved GAFAM. What is DTP goal, which usecase does it handle IRL and why we should, from now on, fight for a right to real time data accessibility instead of portability, those are the questions we'll try to answer.

The right to data portability was intented as a way to enforce competition (and, somehow, to help create european counterparts to GAFAM) and to give back to the public some control over their personal data, but it fails in both situations. The best proof is that GAFAMs themselves are promoting a new common API called DTP (Data Transfer Project) that will never disrupt their market influence. We will analyze in detail how DTP works and why it can't help with decentralization and personal data protection.

What we really need is a right to data /accessibility/, through a common API that will give users the right to access at any time their own data, from whatever service they are using, wherever it is stored.

This is the only way to create some real competition, as one could then chose to move on from a "must have" service without leaving his friends and contacts behind, consequently adopting services that will protect his privacy without making him change his known addresses.

It's a realistic goal: such a right would not be economically unacceptable to GAFAM. The current DTP would be a basic starting point for the development of the new API, that would be a real decentralization opportunity and a real chance for new business models, based on federation of privacy respectful services, to take off.

Uyuni (https://www.uyuni-project.org/), an opinionated fork of the Spacewalk project, provides open source lifecycle management for today's datacenter. With the help of Salt for configuration management it keeps your workloads up to date and secure.

Uyuni manages all your Linux workloads. It bootstraps physical servers, creates VMs for virtualization and cloud, builds container images, and tracks what runs on your Kubernetes clusters. All using Salt under the hood!

It provides you a high-class frontend solution to interact with Salt, manage your states, formulas with forms, and much more using a web UI.

Uyuni is open source, backed by SUSE Linux, and actively developed.

This presentation will give you an overview about Uyuni, its current possibilities for managing datacenters, and how it provides you a powerful frontend to interact with Salt.

Introduction

Graph analysis workloads present resource-intensive computations that require a large amount of memory and CPU time. Consequently, there an abundance of graph processing tools which build on distributed data processing frameworks, including Spark GraphX, Flink Gelly and Giraph (which runs on Hadoop). According to a recent survey, most of these systems build on the vertex-centric programming model, originally introduced in Google’s Pregel paper. This model defines graph analytical algorithms in terms of vertices communicating with their neighbours through message passing, which allows both easy parallelization (for the systems) and intuitive formalization of the computation (for developers). While these systems indeed exhibit horizontal scalability, they introduce numerous inefficiencies requiring a large amount of resources even for moderately sized graphs. Most practical applications only use graphs up to a few hundred million vertices and edges, which can now be stored comfortably on a single machine. For such graphs, it is worth investigating techniques that allow their evaluation without the additional cost and complexity of operating a distributed cluster.

GraphBLAS

The GraphBLAS initiative is an effort to design a set of standard building blocks that allow users to formulate graph computations in the language of linear algebra, using operations on sparse adjacency matrices defined on custom semirings. Since its inception, GraphBLAS has been implemented for multiple languages (e.g. C, C++, and Java). Additionally, GraphBLAS is being designed in collaboration with hardware vendors (such as Intel and Nvidia) to define a standardized set of interfaces, which will allow building specialized hardware components for graph processing in the future.

Multiplex graph metrics

Graph analysis has a significant overlap with network science, a field that aims to uncover the hidden structural properties of graphs and determine the interplay between their vertices. Most works in network science only study homogeneous (monoplex) graphs, and do not distinguish between different types of vertices and edges. We believe this abstraction is wasteful for most real-life networks, which are heterogeneous (multiplex) and emerge by different types of interactions. To illustrate such analyses, we calculated multiplex clustering metrics on the Paradise papers data set to find interesting entities that were engaged in disproportionately high levels of activities with their interconnected neighbours. We found that even on this relatively small data set (2M vertices and 3M edges), naive implementations did not terminate in days. Hence, we adapted techniques from GraphBLAS to optimize the computations to finish in a few minutes.

Outline of the talk

This talk gives a brief overview of how linear algebra can be used to define graph computations on monoplex graphs, and how we applied it to speedup the calculation of multiplex graph metrics. We present the lessons learnt while experimenting with sparse matrix libraries in C, Java, and Julia. Our graph analyzer framework is available as open-source.

Intended audience: users interested in applying multiplex graph analytical techniques for their problems and developers who strive to implement high-performing graph analytical computations.

Speaker biography.

Gabor Szarnyas is a researcher working on graph processing techniques. His core research areas are live graph pattern matching, benchmarking graph queries, and analyzing large-scale multiplex networks. His main research project is ingraph, an openCypher-compatible query engine supporting live query evaluation. His research team was the first to publish a formalisation that captures the semantics of a core subset of the openCypher language.

Gabor works at the Budapest University of Technology and Economics, teaching system modelling and database theory. He conducted research visits at the University of York, McGill University and the University of Waterloo. He is a member of the openCypher Implementers Group and the LDBC Social Network Benchmark task force. He received 1st prize in the MODELS 2016 ACM Student Research Competition conference and 2nd prize at the SIGMOD 2018 competition. He is a frequent speaker at industrial conferences (FOSDEM, GraphConnect) and meetups (openCypher meetup NYC, Budapest Neo4j meetup).

Even the kindest people with the best intentions have blind spots and implicit biases, and these ingrained biases affect the way we work and what we end up working on. Becoming more inclusive will benefit everyone, including you.

It’s fairly easy to talk about the things we share - code, open source projects, development tools. It’s much harder to talk about, and overcome, our differences, especially when we’re talking about about our identities and how we relate to, work with, and build things for others. All societies and cultures have some ingrained biases related to age, gender, religion, orientation, ethnicity, and disability. These affect everyone, not just the non-dominant groups, and can negatively impact innovation, productivity, and the users of the things we create and build. In this talk, I’ll walk through some examples of how more inclusion benefits all of us, and give examples of inclusive practices everyone can use.

CMS Garden is a not-for-profit association run by currently 12 open source content management systems. This talk will show you what is possible when you work together instead of competing each other.

The story about CMS Garden is a story about trust and friendship. Before CMS garden we (as people from different cms communities) thought we were competitors. There was no real comparability between the cms and the most often heard argument was: don't take that $CMS. Take mine (because it's the best). After the first joint event (CeBIT 2013) we knew it's not true. There is no best CMS in the world. There are only good tools for the needs of a project. Sometimes my CMS. In other projects yours CMS.

That event changed everything. Later in 2013 we founded a not-for-profit association and our journey began.

This Lightning Talk wants to share some of the magic moments and try to invite other open source communities to join the garden and adopt the idea of collaboration.

The seamless scaling of a vSwitch in relation to changing platform workloads running in VMs/containers in real-time can be difficult, particularly when the workloads and the vSwitch are independent entities. Typically a user/orchestrator must somehow provision vSwitch cores on-the-fly or even over-provision these cores up-front, in order to ensure the vSwitch can handle the traffic going to and from these workloads at any given time. This talk introduces an approach/approaches to vSwitching that distributes the vSwitching work alongside worker cores, and as a result automatically scales with the amount of work being done on the platform. The approach is likely to be superior to existing approaches in terms of compute cost.

Meet dbdeployer, a tool that helps developers and DBA to deploy and test simple and complex database systems from the oldest versions to the latest ones.

dbdeployer is a tool that helps developers and DBAs to quickly deploy a single MySQL server of any version, without affecting existing servers in the same host. It can also deploy, in a single machine, a test system for replication in several topologies (master/slave, single or multi primary group replication, multi-source replication). The tool creates sandboxes that are equipped with customised scripts that allow users to manipulate and test all the deployed databases. This talk will show the main scenarios where dbdeployer is useful, with examples of usage and tips for a quick start.

The open source (now MIT licensed) FreeRTOS kernel has been helping embedded developers manage the complexity of their microcontroller designs for 15 years – during which time FreeRTOS has gained a reputation for reliability, ease of use, and responsive support. FreeRTOS now runs on RISC-V! In this talk you will see how easy it it to execute the FreeRTOS kernel in open source RISC-V emulators and on physical RISC-V microcontrollers, as well as learn how to port the FreeRTOS kernel to new RISC-V implementations.

This presentation is about tuning FreeBSD OS to give more in the sense of real time audio, possibilities of such a studio and how to make one

With preemptive real time kernel and base system which is relatively small, FreeBSD makes the perfect platform for music production studio. With OSS and Virtual OSS, routing, which is one of the most demanding tasks of any studio, is easy, big number of channels is handled efficiently and support for LV2 plugins in recent year became excellent. Today, if we ignore proprietary solutions, FreeBSD is at least at the level of Linux in music studios, and in some cases it's even better, especially if used PC is older or not powerful. Presenter will demonstrate his own studio from the view of FreeBSD and talk about what is good and what can be improved.

GNU Guix is a package manager and GNU/Linux distribution that builds on Scheme, a Lisp dialect known for its emphasis on minimalism. This talk will be an exploration of Guix’ use of Scheme’s extensibility to build high-level abstractions and user interfaces in a broad sense.

GNU Guix is a package manager, GNU/Linux distribution, and more generally a “software deployment toolbox” featuring key features such as transactional upgrades and rollbacks, declarative operating system configuration, and more. Guix has become a relatively large piece of software but a key aspect of it is that Guix builds on Scheme, a Lisp dialect known for its emphasis on minimalism. From day one, use of Scheme as its single implementation language has shaped Guix.

This talk will be about what it means for Guix to be implemented as a set of libraries on top of this tiny core that Scheme is. Together we will have a guided tour through Guix’ interfaces, be they “programming” or “user” interfaces; we’ll look at its embedded domain-specific languages (EDSLs) that make it just as clear as your favorite YAML/JSON/XML thing while retaining the full power (and joy!) of a general-purpose programming language. We’ll discuss the features of Scheme that make it possible. I will share my thoughts on how such a design can empower users and how well this has worked in practice.

Recently open sourced, JDK Mission Control is the industry standard tool for Java performance analysis in production environments. This presentation will introduce the tool and explain how to use it to solve various production time problems with very little overhead.

We will also discuss how application developers can extend their applications to take advantage of the event recording capabilities of the JDK Flight Recorder, now included in OpenJDK 11, and how to create custom tools based on the extensive Mission Control API to analyse specific issues beyond what is offered by default by the Eclipse based tool.

At the end a demo will be shown using the JDK Flight Recorder, JDK Mission Control and OpenTracing together to facilitate deep distributed tracing capabilities.

The latest and greatest version of PostgreSQL is PostgreSQL 11.

This talk will start off with some history of the community and a description of the development process including some metrics trends. It will then cover a high level overview of the features which will be part of PostgreSQL 11, and prognosticate a bit about the future of PostgreSQL.

Community * History * Development Process PostgreSQL 11 * Patches committed 12 and Beyond * Actively worked items * Under active discussion

I grew up in the Mekong Delta, South of Vietnam. I first learned about free software at a FOSS event in Hanoi in 2007. I started to engage with the local Linux User Group in Singapore during my study time. Later on, I co-founded FOSSASIA - a community devoted to improving people’s lives through sharing Open Technologies and knowledge. I especially wanted to connect people together and to encourage developers from the region to participate in the Free and Open Source Software movement. Since then, FOSSASIA has become one of the largest open source communities in Asia.

During this session, I will speak about challenges and lessons learned in the last 10 years of building FOSS community in Asia.

Enough is a set of tools, online and self-hosted, as well as a community composed of technical people and journalists. The tools were designed to empower journalists and Human Rights Defenders when protecting their privacy, and their sources in the digital era. We will run you through the approach with examples of practical application. We hope to inspire developers and sysadmins to help journalists and provide them with the tools they need when the freedom of the press is challenged.

It‘s not news that journalism has undergone significant changes since the beginning of digitalization: from methods and tools applied in news rooms to the pace at which information is received, processed and outdated, today‘s news are as heavily influenced by modern technology as every other aspect of our lives. While many of these changes contribute to the empowerment of citizens, some of them pose challenges and threats to the traditional role of journalism as safeguard of informed public debates which our societies depend on.

One of them is the growing number of intermediaries involved in communication: Journalists rely on Google, Facebook and other private companies to communicate with sources or store documents online. At the same time, a lack of regulation facilitates the access of governments to data collected by said intermediaries, and legislation introduced all across the globe in the name of terror prevention and protecting national security contributes to curtailing civil liberties. All of these taken together significantly increase the risk of abuse through regulators to inhibit journalists from doing their job – which, in turn, becomes all the more important in that very same context to protect the public interest in a fair and free society.

An answer to this would be to empower journalists to maintain control over their data. But because only few of them have the technological know-how to make use of tools that would allow them to do so, they require support. Establishing closer cooperation between journalists and technological experts is one effective way to close this gap.

This is why we promote the use of the communication platform Enough: based on Free Software exclusively, it offers journalists and Human Rights Defenders a way of communicating and exchanging documents with their sources through an interface that seems familiar to them. At the same time, Enough is embedded and maintained by a decentralized community composed of technological experts, who can support users in technical questions.

ZeroPhone is an (almost) open-source, Linux-powered smartphone that you can source parts for and build independently. During this meetup, you can check out the hardware and software (both the phone itself and the addons), discuss any aspects of the project with the main developer, take a look at the ZeroPhone kits (and, possibly, some yet-not-mentioned hardware), meet some contributors, as well as get some ZeroPhone stickers!

DNS over HTTPS (aka "DoH", RFC 8484) introduces a new transport protocol to do secure and private DNS messaging. Why was it made, how does it work and how users are free (to resolve names).

The presentation will discuss reasons why DoH was deemed necessary and interesting to ship and deploy and how it compares to alternative technologies that offer similar properties. It will discuss how this protocol "liberates" users and offers stronger privacy (than the typical status quo).

How to enable and start using DoH today.

It will also discuss some downsides with DoH and what you should consider before you decide to use a random DoH server on the Internet.

GSH is an implementation of a POSIX shell developed for the Windows platform. The aim of the project is to speed up builds of GNU projects on Windows in a large automated build infrastructures. GSH can be used to compile projects depending on autotools, UNIX make, ... It is up to 2-3 times faster than Cygwin shells for GCC builds.

In this talk I will present:

• what makes GSH faster than other Windows shells for building GNU projects;
• how GSH was developed;
• how you can use it to speed up your builds;
• the limitations;
• what features of Ada we benefit from in this project.

Futatabi is a free software solution for doing instant replay, e.g. for sports production. It supports multiple cameras, high-quality realtime slow motion on the GPU through optical flow, and seamless integration with Nageru, my live video mixer. We'll talk a bit about how interpolation through optical flow works, challenges in transporting the streams back and forth, and demonstrate a real-world sports production done last year using Nageru and Futatabi.

Running a virtual machine enables the user with a high level of flexibility in the expense of the virtual machine's performance. Users are sometimes required to run applications on a virtual machine but still gain performance metrics as close to bare metal as possible. Until now this wasn't a straightforward mission to accomplish in oVirt. A new feature was now added to introduce a simple to manage solution for running a new/existing virtual machine in high performance. In this session we will talk about the essential requirements, functionality, limitations and assumptions for improving virtual machine performance, including host pinning and live migration enabled functionality. Attendees with virtualization knowledge (without necessarily oVirt experience) can learn from this session.

Support a new type of virtual machine in oVirt destined for running a virtual machine with highest possible performance and performance metrics as close to bare metal as possible. By choosing this new High Performance virtual machine type, the virtual machine will be per-configured with a set of suggested and recommended configuration settings for reaching the best efficiency.

Before this feature was implemented in oVirt, configure a virtual machine to run with high performance workloads was not an easy straightforward mission to do and required the user to manually set the virtual machine as such by going over all settings and check what is relevant and how to configure it. In addition, live migration was usually not supported for such virtual machines due to pinning constraints. Furthermore, few required features essential for improving virtual machine performance were not supported at all by oVirt (for example: using huge pages, IO and Emulator threads pinning, CPU cache layer 3 support, USV and other devices disabling, headless mode, enable Multi Queues per Virtual Interface etc).
All these new features and more can now be leveraged to suggest one solution of the best recommended configuration according to virtual machine usage requirements.

We will explain why increasing performance will decrease flexibility of the virtual machine, discuss how to set the virtual machine's devices, pass through host CPU mode, io/cpu/emulator threads pinning typologies, paravirtualized random number generator, virtual NUMA nodes and NUMA pinning topology and more settings. We will also explain how to combine all settings together wisely, what are the requirements from the physical hosts running those virtual machines and what are the limitations. We will also discuss virtual machines' pinned hosts limitations

We will explain out solution for supporting migration for those high performance virtual machines which include pinning configuration, migration constraints to handle and hosts scheduler requirements. In addition we will talk about affinity rules for managing groups of high performance virtual machines and physical hosts.

In this talk, we will introduce FD.io VPP and the Ligato cloud-native networking framework and demonstrate how these are used to address two use cases - a CNI plugin for Kubernetes (Contiv/VPP) and an IPSEC VPN gateway.

FD.io VPP is a high-performance packet forwarder that runs on commodity CPUs. Ligato provides a platform for developing Cloud-Native Network Functions (CNFs) using VPP running in Linux user-space and leveraging Intel's DPDK to grab packets directly from the NIC.

Contiv/VPP is a CNI (Container Network Interface) plugin that uses VPP to provide network connectivity for Kubernetes pods. Its aim is to bypass the kernel for packet handling in a Kubernetes cluster wherever possible. To achieve this, it replaces the kube-proxy load-balancer by leveraging VPP's advanced NAT functionality, and implements native Kubernetes policy (to avoid the requirement for a kernel-based policy plugin). As well as providing fast packet processing, Contiv/VPP can be used as the foundation for CNF deployments running in Kubernetes - since it is based on the Ligato VPP Agent its functionality can be easily extended to interconnect CNFs, e.g. using the Ligato SFC Controller.

StrongSwan is probably the most common IPSEC VPN concentrator in use today. It provides an IKE daemon but leverages the Linux kernel for IPSEC forwarding. Using Ligato we can interface StrongSwan's IKE implementation to VPP's IPSEC forwarding plane to create a high-performance IPSEC VPN CNF.

In general we will look at the benefits of forwarding traffic using VPP rather than the Linux Kernel in terms of: 1) performance 2) flexibility 3) manageability

Good security requires usability. If a secure technology isn’t usable, users will simply use something else - or worse, they might work around the technology to do what they need to do. We will demonstrate this universal truth with a handful of examples and supplement them with good design principles.

We will cover UX of key handling, password managers and anti-phishing, and also spend some time on why these products and services so often lack usability. We also won't miss this opportunity to introduce simple human-centered design methods to incorporate in the development process!

In this talk, Steve will discuss the benefits and challenges his team found using .NET Core 2.1 in production at Namely.com. We'll discuss .NET Core service deployment in containers on Kubernetes, how we monitor our services with logs, charts, and alerting, and how we use service templates and a common .NET Standard helpers library to promote consistency and type safety, and to implement new services fast.

You'll hear about some of the issues we encountered while using .NET Core - such as the BadImageFormatException with New Relic or the HttpClient "CPU leak" issue - and which ones you will still need to watch out for (like Kubernetes OOM-kills).

We've been using .NET Core in production at Namely since 2017. We started with three ASP.NET Core WebAPI projects, and now also deploy .NET Core services that are scaffolded from Protobuf definitions and communicate via gRPC. Steve will talk about some of the issues we encountered while deploying .NET Core 2.0 and 2.1, and how we resolved them (and which ones you'll still have to look out for because they're unfixed as of December 2018). He will also demonstrate the process of how to define a service in the Protobuf format, and how we scaffold our .NET services (and clients) from the proto, taking advantage of some of our common internal NuGet libraries. Steve will demonstrate how to compile a proto to a TypeScript API client - since the server is also scaffolded from the same proto, we call this "NotSupportedException as a Service". Lastly, Steve will talk about how we build and run our .NET services in Docker containers on Linux with Kubernetes deployed via Spinnaker.

On newer generations of Intel Gen GPUs we now have the ability to reset specific engines for a light weight engine reset approach when things go wrong inside the GPU. Instead of resorting to a full GPU reset mechanism from the get go when things go wrong there are less aggressive options that could help us achieve a faster and smoother recovery from a hung GPU. This talk will go over one such mechanism that includes a low latency engine based reset approach through the use of a GPU watchdog timeout. The talk will end by discussing a specific use case under Chrome OS that shows how all the pieces fit together (including how media drivers can make use of this mechanism from user space) and also how a compositor could take advantage of this approach and improve the user experience.

So you did a great job with your website and now your customers want to get into contact with you. They actually want give you their holy grail and apply for a login. And that's where it usually starts to go south. So many things can go wrong with a registration form that your customer doesn't really feel welcome or safe. In this session we will debug a few real-life examples from a user-experience Point of View. By analysing that we will find ways to make the first contact of a user with our application a better experience. And you don't need to be a coder to see why and how to improve your next registration form.

The Online code-base can bring LibreOffice into an iframe in your web app. Come and hear how this works, how to integrate it with your software, and about all the options and tweaks that go with this.

Online uses a WOPI-like protocol, and it is simple to integrate. Come hear about the total of three REST methods you need for a simple integration. Hear about the wealth of options to control sharing work.

See how Online works, and how you can get involved with building, debugging, and developing it, and checkout some of the new features we've been working on to make life better for our users.

License Compliance has become big business. Many proprietary tools exist, but fortunately in recent years FLOSS tools to aid understanding the licenses of codebases have been created. This panel includes developers of many of these freely available tools. We'll discuss what these tools do, if they can actually address compliance problems in the wild yet, and the general challenges of developing freely available tools in a heavily proprietarized industry.

NMState is a new declarative API that simplifies Linux network management.

Various services built on top of Linux need to manage the network configuration. Each service models network entities differently and uses various APIs to change the network state, multiplying the required work. NMState centralizes the challenges by providing a unified declarative representation of the Linux network state and allowing to modify it using the same schema. NMState also provides Ansible network modules to manage Linux systems, conforming to the same uniform schema used to control network appliances. The talk will introduce NMState, its core capabilities, current users and roadmap, including plans for Kubevirt, oVirt, Openshift and Openstack support. Afterwards, the audience will understand the benefits of using NMState to centralize collaboration on Linux network management.

Private clouds are all the rage!

Ok, not really, but privacy violations certainly are. Facebook, Dropbox et all are not exactly providing a safe home for your family pictures and as such, alternatives are sought after. Nextcloud gives you a place where your data is stored, designed to protect rather than exploit it. Self-hosted or at a provider you trust, your Nextcloud lets you share, chat and edit documents with others or alone in the same way the big American players do. But you stay in control. Shouldn't that be all the rage?

In this presentation I'll touch on the subject of privacy and why you should care about it, showing you what drives us to make Nextcloud. Next I will cover the results of our work: a real alternative build for real humans!

Nextcloud is a private file sync and share solution that can take care of not only your files but also your calendars and contacts, your passwords and news feeds, notes, audio/video or text chats and so much more. Over 150 apps developed by the largest open source file sync & share community give you everything you care about, and more.

Nextcloud is 100%-no-shenanigans-open-source, because we think that that's best for everyone involved. And you can contribute, join our awesome community!

Go is, for all its C-esque syntax, is a relatively high-level language. There’s garbage collection, a type hierarchy, and even advanced concurrency primitives. Sometimes, though, you need access to lower-level control. Whether for performance, interoperability, or just for fun, the Cgo API is here to help! I will explain what it is, how to use it, and perhaps most importantly, when to avoid it.

A lot of Go programmers only experience with Cgo is when compilation fails with some obscure error. There’s a lot more to learn than that, and a lot of opportunities! I’ve personally used Cgo for writing Postgres foreign wrappers, and as a consumer when compiling Kubernetes.

Using Cgo can be a fun, rewarding experience. There are a lot of existing projects and libraries written in C, and calling them means not needing to reinvent the wheel. On the same face, if you have an existing project with a C API, calling Go can get you some of the higher-level Go niceness on top of the jagged C edges.

Some things I intend to touch on: * Calling Go from C * Calling C from Go * Memory management with Go objects in C * Using C libraries from Go * Real-world Cgo examples * The pitfalls Go and dynamic linking * Debugging failures

When your SQL query reaches the DBMS, it's the optimizer job to decide how to execute it for you to get the result as fast as possible. To make this decision optimizer can examine the actual table data, but with multi giga- and terabyte tables, the only practical solution is to use various data statistics that was collected in advance. The better the statistics is and the more precisely it describes the actual data, the faster the plan will be, because optimizer image of the reality will be closer to the actual reality.

In this talk you'll learn what data statistics MariaDB and MySQL can collect, what statements do that, how to tell the optimizer to use it (it won't necessarily do it automatically!) and how it can make your queries many times faster.

And, of course, when not to use indexes, when up-to-date statistics is enough.

The Transport Layer Security (TLS) protocol is the security backbone of the Web, and is used my millions, if not billions, of users of a daily basis. Weaknesses in TLS 1.2 and below, as well as pressure to improve the protocol's efficiency, lead the Internet Engineering Task Force (IEFT) to engage in development of a new version of the protocol, namely TLS 1.3. In the design of TLS 1.3, the IETF welcomed analyses of the protocol prior to its official release, with the intention of remedying flaws and weaknesses before users would be affected. This "analysis-prior-to-deployment" design process was in sharp contrast to previous versions of the protocol. In this talk I will present two analyses of TLS 1.3 using the Tamarin prover, a state-of-the-art formal methods tool designed specfically for cryptographic protocol analysis. The first analysis, of draft 10, found a serious attack against the protocol and informed the next draft of this critical protocol. The TLS 1.3 draft, however, was a rapidly moving target, and the second analysis effort, of draft 21, went on to confirm the stability of the protocol, showing that after four years of development, the logical core of the protocol was sound. This confirmation gave the IETF confidence to release the protocol, and it was officially approved in August of 2018.

n this talk, we introduce Strawberry Fields, an open-source quantum software library for light-based quantum computers. Built in Python, Strawberry Fields is a full-stack library for design, simulation, optimization, and quantum machine learning of photonic quantum circuits. The platform consists of three main components: (i) an API for quantum programming based on an easy-to-use language named Blackbird; (ii) a suite of three virtual quantum computer backends, built in NumPy and Tensorflow, each targeting specialized uses; and (iii) an engine which can compile Blackbird programs on various backends, including the three built-in simulators, and – in the near future – photonic quantum information processors. The library also contains built-in examples of several paradigmatic algorithms, including teleportation, (Gaussian) boson sampling, instantaneous quantum polynomial, Hamiltonian simulation, and variational quantum circuit optimization.

A short talk about Autocrypt, a standard for decentralized and automated public-key management for e-mail encryption, built on OpenPGP.

Autocrypt is a set of guidelines for developers to achieve convenient end-to-end-encryption of e-mails. It specifies how e-mail programs negotiate encryption capabilities using regular e-mails. For users, Autocrypt Level 1 offers single-click, opt-in encryption, eases encrypted group communications, and provides a way to setup encryption on multiple devices. It builds on the OpenPGP standard for compatibility, but tries to automate key management for the user as much as possible, without relying on provider support or centralized infrastructure. It is supported in Enigmail as well as K-9 Mail, among others. In a short talk, we'll go over our technical as well as our cultural approach.

https://autocrypt.org/

Two years ago on FOSDEM'17 a minimalistic bootstrap was a dream; today it has started to become reality. Bootstrapping GNU/Linux without use of the GNU toolchain (gcc, binutils, glibc) was our first milestone that we just reached. Mes became a GNU project. We will talk about what bootstrapping is and why it is important.
We will show how Mes' minimalistic Scheme has made this possible and on future milestones (Scheme only bootstrap, other GNU/Linux distributions) before reaching the holy grail: a full source bootstrap.

When doing benchmarks we are usually interested in comparing the throughput of different solutions. However, when the code under investigation is not trivial, memory consumption may vary significantly, because using more memory to achieve better throughput is a typical design trade off.

The talk discusses what memory metrics are more or less meaningful and what approaches can be used to track memory consumption alongside JMH benchmarks. A special focus will be given on dynamic effects on the interaction with the garbage collector and whether it is possible to get some stable benchmark results.

Mgmt is a real-time automation tool that is fast and safe. It works by running a DAG (graph) of resources. The DAG is built in real-time, by running a graph-based DSL (language). We'll fill this talk with a number of exciting real-time demos that show how some cleverly applied graph algorithms can solve an incredibly difficult set of problems. We'll finish this off by including a demo of building a real-time, distributed, finite state machine (a distributed graph) using our tool.

Mgmt is a real-time automation tool that is fast and safe. It works by running a DAG (graph) of resources. The DAG is built in real-time, by running a graph-based DSL (language). We'll fill this talk with a number of exciting real-time demos that show how some cleverly applied graph algorithms can solve an incredibly difficult set of problems. We'll finish this off by including a demo of building a real-time, distributed, finite state machine (a distributed graph) using our tool.

A number of blog posts on the subject are available: https://purpleidea.com/tags/mgmtconfig/ Attendees are encouraged to read some before the talk if they want a preview!

It is often difficult to untangle technical choices made when designing systems from the values and implicit assumptions of its those systems' designers.

For many developers of open-source software, radical openness and permissionless participation have become the de facto methodology to follow when designing collaboration systems. This ideology has driven the creation of a wealth of information systems and collaboratively curated data sets which could not have been created in a top-down fashion. Consequently, different values, and thus different architectures have remained largely unexplored.

This lecture will present CryptPad, a web-based suite of collaborative tools which employs client-side encryption to restrict access to those who possess the cryptographic keys which are unique to each document. I will include an overview of the underlying architecture, and provide insight into its design process and the values that it encodes.

This talk was originally proposed by Aaron MacSween.

Microservices propose a new paradigm to split monolithic cloud infrastructure into unitary services which allow better scaling of the global infrastructure by integrating heterogeneous technologies. Current cloud infrastructure allows to implement cheap microservices by hosting them in VMs. To leverage host resources, VMs are launched on demand, i.e., when the microservice is idle, the VM is shutdown and it is only powered on when a request arrives. In this context, the time that takes the VM to be ready and serves incoming requests becomes very important. We have identified two problems that prevent VMs to start up on time: first, the initialization of the hypervisor, and second, the size of the image. In this talk, we present three approaches that work around on these problems, i.e., Qboot, NEMU and Firecracker. We evaluate these approaches on a Toro appliance that is a unikernel dedicated to microservices. In Toro, the kernel and the microservice are compiled together and the result is a single image that can be used to launch a Virtual Machine (VM) on different hypervisors like Xen, KVM or HyperV.

An exploration of using Go to build a hardware MIDI player, complete with floppy drive, on a minimal Linux distribution, gokrazy. Without our standard system utilities, in this talk we'll explore Go's syscall interface, as well as Linux's other interfaces, such as netlink and kobject. There will also be sweet, sweet chiptunes.

In this talk, I'll be talking about the hardware MIDI project powered by Go I built in 2018, inspired by the mid-90s Roland MT-80S.

This MIDI player was built on a Raspberry Pi using a USB floppy drive. It's using the minimalist and Go-focused Linux distribution gokrazy. As gokrazy doesn't provide the usual system utilities, your project is expected to handle everything, this is a good project to explore the system interfaces. The three main interfaces I'll be exploring are:

• syscall: The unix syscall interface, golang.org/x/sys/unix. These are calls into the kernel, and while large, the syscall interface is extremely powerful for low level system administrative tasks.
• netlink: A family of RPC interfaces with the Linux kernel. The kernel implements this interface where function calls and directly passing structures in memory would be more difficult.
• kobject: A stream interface, related to netlink, where the kernel can inform userspace (that is, us!) about objects changing in the kernel, such as hardware devices being added or removed.

By pulling these interfaces together with Go, we can build a MIDI player that starts playing when a floppy disk is inserted. There will be chiptunes.

Open discussion about getting more designers participating in Open Source projects and better understanding of the barriers that may be preventing them from contributing.

We will invite several designers into the panel, to share their experience with their open source communities and provide insight on the topic. Some questions will be interactive and the public can also vote and respond, representing their opinion.

This talk will cover the on-going process of migrating a big data cluster from a Linux-only system to a mixed OS environment using more and more BSD. I'll cover how the cluster started, what it is used for and the current setup (hardware and software). Particular focus will be put on the migration of the fileserver that has been successfully migrated from a hardware RAID configuration using Linux to an OpenZFS-based FreeBSD setup. I'll detail how it was done, the planning, preparation, and important learnings I too away from the experience. The talk closes with an outline of what steps will follow in the future. The talk is intended for people interested in such setups, migration strategies, steps to take and pitfalls to avoid.

I manage the Big Data cluster of the University of Applied Sciences, Darmstadt, Germany as system administrator. As such, I'm responsible for providing the compute resources to researchers and teachers during the semester, as well as students doing projects and thesis work on the cluster nodes. When I took over the cluster a couple of years ago, it was a Linux-only system. I've managed to convert more and more nodes to using FreeBSD and OpenZFS. My talk will focus on the how and why, elaborating benefits of the approach and rough edges that still need to be worked on. In the summer of 2018, I took on one of the biggest tasks yet: the migration of the central file server for the cluster. This fileserver provides the home directories to each node via NFS. I was successful in migrating it from a pure hardware RAID setup to a FreeBSD-based OpenZFS software RAID solution. This provides the usual benefits associated with OpenZFS such as compression, quotas and reservation, as well as data protection on various levels. My talk will detail the preparation that I took before the migration and provide some insight into how the setup works now. Future work is discussed and I hope to gather some feedback from the audience about topics like monitoring, backup, and outstanding work.

Nextcloud enables you to regain control over your data and freely share and sync them. That's probably the part of Nextcloud most people are already familiar with. But Nextcloud takes huge efforts to go beyond handling your data and provides strong collaboration and communication tools. In 2019 most people not only want to store their data, they are looking for a integrated platform which allows them to do actual work with their data. In this context collaborative editing but also video, audio and text chat, integration with your contacts and calendars and many more play an important role. If you want to do this without losing the connection to your friends, family and co-workers strong federation capabilities are needed. Federation is at the heart of Nextcloud and was completely re-written last year based on the vendor neutral Open Cloud Mesh (OCM) specification.

Additionally to the OCM implementation which allows you to share data across Nextcloud instances, we are excited to announce that with Nextcloud 15 we joined the Fediverse with our own ActivityPub implementation. This turns every Nextcloud user into a participant of the free, open and federated social network and allow them to communicate with people on Mastodon, Friendica, Pleroma and many more. Join the talk and learn what you can do with Nextcloud and how to join the cloud federation.

This presentation will tell the story of integration of a 3rd party document signing service (provided by Vereign) into LibreOffice Online.

We are (too much) used to software having bugs as an unavoidable fate. But for safety-critical software, like the code that's driving planes or trains, "Failure is Not an Option".

This presentation exposes the constraints of such software, and how they require a special state of mind, special methods, and special tools - like Ada and SPARK. And these can be useful for more casual programming - zero bug software is nice, even when not safety-critical!

SReview is a conference video review system, originally written for FOSDEM 2017, that is now being used for the third time at FOSDEM 2019. It is also in active use by the debconf video team.

This talk will explain the background in which it was written, and will also give a somewhat detailed explanation of its inner workings.

For an explanation of the detailed UI design work we did to the review page over the last year, see the companion talk in the open source design devroom.

APIs strive to make programmers’ jobs easier by staying stable. Less attention is paid to make the jobs of system administrators easier by providing stable configuration interfaces. These interfaces consist of configuration file formats and various utilities that often change with new major OS releases. Ansible is a great tool for system management, but keeping Ansible playbooks working across major distribution version upgrades can be challenging due to this interface instability. We present Linux System Roles (github.com/linux-system-roles) which allow to manage RHEL, CentOS and Fedora with sufficient abstraction to enable using the same playbooks for different releases and to avoid the need of changing playbooks due to implementation changes. The main difficulty of this approach is getting the interface right to avoid the need of incompatible changes in the future. We will show how to use Linux System Roles with Ansible to configure your Fedora, RHEL or CentOS systems and discuss the challenges that one may encounter when designing such a system or Ansible roles in general.

APIs strive to make programmers’ jobs easier by staying stable. Less attention is paid to make the jobs of system administrators easier by providing stable configuration interfaces. These interfaces consist of configuration file formats and various utilities that often change with new major OS releases. Ansible is a great tool for system management, but keeping Ansible playbooks working across major distribution version upgrades can be challenging due to this interface instability. We present Linux System Roles (github.com/linux-system-roles) which allow to manage RHEL, CentOS and Fedora with sufficient abstraction to enable using the same playbooks for different releases and to avoid the need of changing playbooks due to implementation changes. The roles currently support configuring: - kdump - SELinux - networking - time synchronization - postfix - storage - logging

The main difficulty of this approach is getting the interface right to avoid the need of incompatible changes in the future. We will explain and discuss the choices that we made in the design of the interfaces of our roles. We expect our experience to be generally useful for those who design Ansible roles.

Attendees will gain a practical understanding of how to use Linux System Roles with Ansible to configure their Fedora, RHEL or CentOS systems consistently across multiple releases. The audience is assumed to have a basic understanding of Ansible and experience with Linux (preferably Fedora-derived) system administration.

Medical image reconstruction is a highly demanding topic in terms of processing power, memory consumption and computational complexity. In the past several low level approaches have been conducted that improved performance but made such systems become inflexibel and reduced maintainability. This presentation shows a setup of using the .NET framework as well as a GPU-based integration in the C# language. Several topics in image reconstruction and processing will be shown in the context of medical image processing. Additionally, challenges and problems of .NET and C# are discussed.

Since the introduction of Computed Tomography (CT) as a medical diagnostic imaging procedure 40 years ago, there are still unresolved challenges regarding radiation dose, image quality and image reconstruction. One of the major concerns is radiation dose applied to the patient and - not frequently mentioned - the medical staff. For that reason, several new inventions have been made that improve the equipment of the CT-scanning device, for example X-ray sources and detectors systems. Recently, new developments in the computing power of modern computers have led to new approaches that enable the replacement of traditional reconstruction methods (filtered backprojection) by using iterative or AI-based methods as well as cloud-based approaches that allow both, the reduction of radiation dose and a tremendous improvement in image quality.

However, evaluating new methods require a solid development environment to allow for and simple and convenient implementation of new ideas and algorithms. Although there are several well-known and established platforms that are a good starting point for plain prototyping, an efficient execution of code inside these platforms is often challenging with regard to the management computing power and memory resources. Additionally, shipping prototypes to customers for evaluation is often not easy.

This presentation starts with a basic introduction into medical image acquisition and reconstruction, followed by a short explanation of the storage of image data using the DICOM (digital imaging and communications and medicine) standard. Afterwards it is shown how the .NET environment using C#, .NET and .NET Core, WPF and the nVidia computing platform (CUDA) can be applied as a modular prototyping platform for developers, researchers and customers in order to develop new algorithms and to conduct clinical and scientific studies.

The presentation will end with a summary of state-of-the-art development with C# and point out challenges that exist with managed runtime environments regarding memory management, performance and missing language and CLR features that would help to further improve the development within the C#/.NET environment in the light of high performance computing.

HelenOS is an open source operating system based on the microkernel multiserver design principles. One of its goals is to provide excellent target platform portability. From the time of its inception, HelenOS already supported 4 different hardware platforms and currently it supports platforms as diverse as x86, SPARCv9 and ARM. This talk presents practical experiences and lessons learned from porting HelenOS to RISC-V.

While the unprivileged (user space) instruction set architecture of RISC-V has been declared stable in 2014, the privileged instruction set architecture is technically still allowed to change in the future. Likewise, many major design features and building blocks of HelenOS are already in place, but no official commitment to ABI or API stability has been made yet. This gives an interesting perspective on the pros and cons of both HelenOS and RISC-V. The talk also points to some possible research directions with respect to hardware/software co-design.

In the past couple of years there's been renewed enthusiasm for improving the open source email client standards, with multiple new IMAP standards becoming RFCs, and a revision of the base IMAP standards currently in evaluation.

As the working group co-chair of both the JMAP (new email standard) and EXTRA (updating existing standards) working groups at IETF, I've been following email standards closely. I'll talk about what's happening in both working groups, how to find the specifications, and some cool new things you can do as an email client (or server) author.

XR has been trending for many years, and so far we've all seen awesome demos, like being on the moon, on a roller coaster, playing horror games and watching 360 videos. But while we're busy creating standards, we're forgetting the most important part of XR. Our brain.

Now, I'm not saying that we shouldn't develop what we've been already developing. But, XR is, in fact, a technology. That's more than a content medium. XR has recently used for treatment for PTSD, ADD & ADHD, OCD, various phobias, and even for vaccinations. So, what else is XR being used for? And how do tools developed by Mozilla help? Let's find out!

Many have recognized the advantages of containerization and container platforms for traditional web server and database apps. With the expansion of IoT as well as Telco and service providers’ workloads into containers, there is an increased focus on NFV, and other non-traditional networking intensive applications. These applications require layer two and three access to high performance data planes from within containers and Kubernetes pods. In this session, we will dive into the particular requirements for layer2 and layer3 containerized applications. We will also discuss and compare some solutions such as Network Service Mesh (NSM) and Multus and how they are used for the connection and orchestration of NFV containerized workloads.

The CAP theorem is often used to describe the tradeoffs of available versus consistent systems. But the CAP theorem is often misunderstood and misrepresented. In this session we investigate the CAP properties of various MySQL replication setups, and show that it is impossible to claim a setup is AP or that it is CP. We will see how the properties can be non binary, and change across time, geography and workload. We will also observe where CAP's terms can be made irrelevant. This session takes the practical engineer's perspective and shows how we can gain the upper hand with reasonable tradeoffs.

There's a new major version of the Guile language implementation coming, and it's on average around twice as fast as Guile 2.2. Guile 3, expected to be released in Spring 2019, achieves these improvements by adding on a just-in-time compilation system to its virtual machine. Co-maintainer Andy Wingo will walk you through how we managed to achieve these improvements while not increasing startup latency, and give tips and tricks for early adopters.

One of the ways Java achieves high performance is to provide a route for accelerated, hand-crafted compilation of certain critical methods via the JIT. This optimization path is available both for native methods implemented as callouts to C code and for methods that are defined in Java. In both cases the method needs to be flagged as a HotspotIntrinsic and provided with a JITted code implementation. The intrinsic implementation defines the hand-crafted definition of as a high-level intermediate representation (IR) graph for the C2 JIT. This means it can be inlined into the IR graph for caller methods, providing even greater opportunities for optimization.

This talk will demonstrate how to implement an intrinsic by walking through a specific real-life example that is currently under review as a JEP candidate. It will start by motivating the need for the intrinsic and defining the candidate as a Java method which relies on an underlying native implementation. It will then show how the candidate can be replaced with an intrinsic implementation, working through the changes required in the VM, the JIT compiler front and back end and, ultimately, the assemblers for x86 and AArch64.

I will demonstrate an easy and fast way of configuring Tiki Wiki CMS Groupware for the purpose of having a central repository for a knowledge base. I will also explain how to manage permissions for various use cases, how to separate different topics, how to access stored knowledge.

This presentation will start with a minimal Tiki site and show how to build structures of pages and file repositories with a knowledge base in mind. This will rely on a concrete real-life working example of a site for collaboration between a freelancer/company and their various separate customers with different projects.

I will show how to configure permissions for: * a publicly visible and editable knowledge base; * separate knowledge bases which are restricted to groups of users and invisible to others; * intermediate scenarios with groups of editors and groups of read-only viewers.

I will show the basics of how to make the knowledge accessible, searchable, navigable and allow comments from people who can only view it.

I will provide hints about more powerful approaches using Tiki's inbuilt user-configurable database feature.

LibreOffice Impress was capable of importing your SmartArt graphics from PPTX files for a long time. Today this is a popular feature, and we only do a good job of rendering this shape type when the file has a fallback rendering included. LibreOffice 6.3 will contain a long series of small, incremental improvements in this area, resulting in a large step forward when it comes to laying out SmartArt document models. This will be a major improvement for documents which don't have a pre-rendered layout included. The result affects both desktop LibreOffice and the Online. Come and see how this work is implemented, where are the still rough edges and how you can help.

Streaming video on the internet in 2019 is littered with a cacophony of proprietary, patent encumbered technologies. As the landscape of the internet evolves libre video technologies are becoming more prominent in browsers and on devices, but we’re still a long way from a complete solution.

In this session we’ll walk through the state of libre video on the internet and pick technologies to reach as many users and devices as possible while suggesting workarounds for the problems we find. We’ll also explore how we can leverage adaptive bitrate technologies within a libre video technology stack to provide a seamless user experience.

Finally we’ll also take a forward facing look at the future of online video and how AV1 can help bring libre video to the masses.

In this presentation, we will talk about the Intel Hardware Intrinsics in .NET Core, a new feature in .NET Core 3.0. For the first time, .NET developers will have the ability to directly exercise underlying CPU features, very similar to what C/C++ developers could do with intrinsic functions for their performance critical code. The Intel Hardware Intrinsics in .NET Core include more than 1300 intrinsic functions, which cover the instruction set architecture (ISA) SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, FMA, LZCNT, POPCNT, BMI1, BMI2, PCLMULQDQ, and AES. Many of the intrinsic functions are designed for Single Instruction Multiple Data (SIMD) computation, a common used technology to speed up computation intensive algorithms. To illustrate the benefits of using Hardware Intrinsics, we implemented a Structure of Array (SoA) based RayTracer and compared its performance with that of the traditional Array of Structure (AoS) based RayTracer which uses System.Numerics.Vectors. Our experience shows that significant performance improvement is possible when using Hardware Intrinsics for this particular application. Another use case is ML.NET, an open source machine learning framework for .NET developers, which leverages the Intel Hardware Intrinsics to simplify the acceleration of machine learning scenarios.

We will give an overview of SIMD and the Intel Hardware Intrinsics in .NET Core. In addition, we will talk about the differences of System.Numerics.Vectors and System.Runtime.Intrinsics, which are the two different ways to use SIMD in .NET Core. we will show live demos on how to use Intel hardware intrinsics. By the end of the presentation, the audience will learn the current status of the Intel Hardware Intrinsics in .NET Core and how to use the Intel Hardware Intrinsics to speed up their code.

The introduction of the 64-bit version of the x86 architecture allowed servers to operate with much larger amounts of memory and the use of memory pages of different sizes. This talk will explore the Linux kernel implementation of HugePages in view of two of the most popular open source RDBMS, MySQL and PostgreSQL. We will be looking at how HugePages works, what is necessary to configure to make use of it, and whether it is really worth and under which circumstances.

The turn of the century saw the introduction of the 64-bit version of the popular x86 instruction set. The flagship feature of this new architecture specification was the use of a larger physical (and virtual) address space, increasing the practical memory limit of 4GB (or 64GB when in PAE mode) found in 32-bit x86 processors to values expressed in the order of Terabytes. Beyond the obvious advantage of operating with more memory, a bigger address space allowed programs to store larger amounts of data in memory: in many cases it made possible the mapping of entire files (instead of only fragments of it) in the respective process' address space.

Another important factor to consider in this context is the translation of virtual memory (divided in "pages") into physical memory. This direct mapping is maintained in a data structure called "page table". However, each lookup made there is an expensive operation, thus the Memory Management Unit (MMU) employs a caching mechanism named Translation Lookaside Buffer (TLB) for faster lookups. Whenever a translation from virtual memory to physical memory is necessary the TLB is verified first. If the target entry is found to be there the physical address is promptly returned, otherwise a TLB miss is computed and a more costly lookup in the page table is made. But as any other cache, it can only fit a limited number of entries. Making optimal usage of this space is important: the bigger the page size is the most of the memory area will be mapped by the TLB. Applications that perform a lot of memory accesses may obtain performance improvements by using large pages due to reduced TLB misses (https://dev.mysql.com/doc/refman/8.0/en/large-page-support.html).

A class of software that potentially benefits from operating with huge pages is that of database systems with their particular caching mechanisms. The PostgreSQL manual (https://www.postgresql.org/docs/9.6/static/kernel-resources.html) states that "using huge pages reduces overhead when using large contiguous chunks of memory, as PostgreSQL does, particularly when using large values of shared_buffers".

While MySQL and PostgreSQL do have support for huge pages MongoDB doesn't. Applications running in userland that do not natively support huge pages may indirectly make use of them through a kernel feature named Transparent HugePages (THP). But does it works the same ?

Furthermore, the enabling and use of huge pages is not made through a simple configuration flag that may be turned on or off: one needs to specify the number of huge pages needed in advance as well as the preferable page size. How should a database administrator makes this choice, and based in which factors ? Is there any tweaks necessary in the database side in order to benefit from huge pages ? What are the possible drawbacks in its use ? In this presentation we'll have a look at how this applies to MySQL and PostgreSQL.

Help my client is complaining some parts of the application are slow. Now what?

Profiling!

What is profiling and how can we measure the performance of our application? There are several tools we can use. Once we have the tools, how do we approach profiling. What to look for. And caveats to avoid when profiling. To finish up, we should avoid that our client is complaining about performance, how can we pro actively use profiling to improve our application.

When finished we will end up with a nice toolbox of profiling tools and good ideas how to do profiling and avoid some common mistakes that might distract you from the real optimisation.

Classical Kubernetes workload consists of microservices, that are relatively cheap to restart and reschedule. With the expansion of containerized application technologies, heavier, longer-living applications are looking to leverage Kubernetes. These applications may keep a complex state that is hard to relocate and may have strong hardware requirement. Thus, stopping and rescheduling them is more expensive and disruptive to the application. For such applications, an administrator would like to modify the configuration of the cluster nodes on-the-fly. In particular, this is important for network-related changes, such as setting SR-IOV cards or defining bonds. In this talk you will learn about kubernetes-nmstate. A tool that allows Kubernetes administrators to dynamically configure networking on cluster nodes.

Attendees will learn how to configure node network from the Kubernetes API

Go is an excellent tool for concurrent programming. Goroutines and channels make it easy to coordinate multiple interacting processes. With careful design, good concurrent Go programs run efficiently on multi-core CPUs because multiple goroutines can run in parallel on multiple CPUs.

What is less known is that Go also works very well for expressing parallel algorithms that do not communicate via channels, but access shared memory directly. This goes against Go’s famous slogan: “Do not communicate by sharing memory; instead, share memory by communicating.” However, sometimes performance matters so much that you have to make an exception.

Fortunately, Go is a very powerful language and makes it easy to make such exceptions. In this talk, I am going to walk you through Pargo, an open-source Go library explicitly designed for parallel programming rather than concurrent programming, which is available at https://github.com/exascience/pargo. This library is based on several years of experience with parallel programming at the ExaScience Lab at imec in Belgium, with many programming languages (C, C++, Java), many parallel programming libraries (Cilk, OpenMP, Intel Threading Building Blocks), and many applications (physics simulations, DNA sequencing, statistics).

Go already provides primitives that help with parallel programming in the sync and sync/atomic packages of its standard library. Pargo builds on top of these primitives and offers high-level functions and data structures for expressing parallel algorithms. This covers simple convenience functions on top of goroutines, efficient parallel maps, parallel sort functions, and a very powerful pipeline concept for efficiently processing large data sets.

This talk will cover the following topics:

• How Go schedules goroutines, and why they can therefore be used for task-based parallel programming.
• How Pargo provides a number of parallel programming primitives to make task-based parallel programming easier.
• How parallel Quicksort and Mergesort can be implemented with Pargo.
• How Pargo allows you to write parallel pipelines for efficiently streaming, filtering, and transforming large data sets in parallel.

Pascal Costanza has a Ph.D. degree from the University of Bonn, Germany, and works as a senior researcher at imec, Leuven, Belgium. He was previously employed by Intel Corporation, and Vrije Universiteit Brussel, Belgium. He is an expert on high-performance and data-intensive computing with applications in bioinformatics, sequencing pipelines, and artificial intelligence.

Eventyay is built based on the experiences and lesson learned from organizers of FOSSASIA Summit after a several years searching for suitable solution.

This is a update on the current development of eventyay, the tech stack and feature set.

(Please note that it was originally advertised that Hong Phuc Dang would be giving this talk.)

Numerous open-source projects develop software-defined data planes targeting network use cases such as Discrete Appliances, Cloud Infrastructure, Virtual Network Functions and now also Cloud-Native deployments. These may be based on foundation toolkits such DPDK, eBPF/XDP, Snabb and so on, and may implement a diverse range of network functions, applied in many combinations and on different compute platforms and devices.

The need for a consistent and repeatable, use-case driven performance validation and benchmarking approach has never been greater. Enabling both the development community and the end-user to understand, measure and verify expected performance.

Achieving great performance with Network Software, should not be accidental, it should be data-driven!

This talk explains how the FD.io CSIT project aims to meet this need by developing and providing Continuous Performance Lab platform for benchmarking, validation, performance trending and regression detection. Founded on multi-vendor collaboration, CSIT leverages deep multi-platform understanding and telemetry tools to analyze and correlate benchmarking results leading to consistent, repeatable and reliable performance validation the FD.io user base can rely on.

This talk will cover

• A brief overview of FD.io CSIT
• Recent FD.io VPP release performance data is presented and discussed in this context.
• Recent CSIT Community Innovations Performance Trending graphs, MLRSearch and PMU Tooling are presented.
• Debugging a real system setup issue with FD.io CSIT is also covered

Netflix has built a CDN to distribute streaming media through most of the world. The content caches run a lightly customized version of the FreeBSD operating system. This presentation will describe how Netflix uses FreeBSD, and the benefits to both FreeBSD and Netflix.

Netflix has built a CDN, called Open Connect, to distribute streaming media through most of the world. According to Sandvine, Netflix accounts for approximately 15% of all downstream traffic volume across the entire internet. The content caches in the Netflix CDN, also known as Open Connect Appliances (or, simply, OCAs), run a lightly customized version of FreeBSD.

In some ways, this is nothing special: many products are based on an open-source operating system. However, Netflix does something slightly unusual, in that its OCA operating system code closely tracks the FreeBSD "head" branch (their development branch). In fact, a commit to the upstream FreeBSD development branch will usually be fully deployed across Netflix's CDN within 5-15 weeks.

The Netflix development team strives for monthly releases for the content caches. We try to synchronize the latest code from FreeBSD's head branch at least once during each monthly release cycle. We then test this code thoroughly before deploying it across the Open Connect network. It is common that we find at least some bugs; however, we are able to work with upstream developers to fix these while the commits are fresh in their mind. This early (and widespread) use of the code gives the upstream FreeBSD Project the benefit of quick deployment and validation of their development-branch code across a wide fleet of servers. Netflix gets the benefit of being able to quickly use new features, and of getting quick bug fixes.

Although it might seem scary to run "development" code in production, we find that it works very well in practice. The FreeBSD development branch is usually quite stable. Additionally, we expect that we will find some bugs. However, we find that it is much better to find and fix those sooner, rather than later. Also, Netflix is committed to upstreaming most of our customizations that have general applicability. Tracking the upstream development branch keeps us in the best position to easily upstream our changes.

In this presentation, Jonathan Looney will explain how Netflix uses the FreeBSD development branch code to help Netflix produce the robust operating system which supports the Netflix CDN, and the synergies Netflix and FreeBSD see through this use.

Pulp is a platform for managing repositories of software packages, and its plugin architecture allows management of any type of content. Pulp’s web API enables users to synchronize, upload, and publish versioned repositories with simple but flexible workflows. This presentation will build on last year’s talk by Dennis Kliban 0, and will highlight simplified installation and deployment, better performance, new features, and a growing collection of plugins including rpm, python, docker, ansible, chef, ruby, file, and more in development. Pulp 3 is approaching maturity and is ready for you to test drive.

Presentation on the recent "flickerfree" boot work, where the goal is to go from the firmware splashscreen/logo to the GUI in one fluid experience without any modesets (causing the screen to blank) or transitions to text-mode. Topics discussed during the presentation are:

• The changes made to each of the involved components
• The upstream status of these changes
• Steps to take to enable this

A typical UEFI boot of a Linux system looks like this: * firmware shows a boot logo * shim loads, clears the screen * grub loads, shows a text menu * kernel efifb loads, clears the screen, may show a bunch of text messages * kernel drm/kms driver loads * bootsplash (plymouth) loads * GUI loads

Where the kms driver, plymouth and GUI load all may do a modeset resulting in the display loosing signal for a while. The constant screen clearing, various text-messages and the modesets all result in a quite restless boot experience.

My latest project at Red Hat is fixing all this so that we go straight from the logo shown into the GUI, while still being able to show error messages at all stages if necessary.

During this presentation I describe: * The changes made to each of the involved components * The upstream status of these changes * Steps to take to enable this

Benefits to the eco-system:

1) A nicer boot experience for all Linux systems makes Linux more user-friendly and will hopefully lead to wider boot experience

2) Customized embedded systems can already offer a similar experience by disabling the kernel's fbcon driver. There are 2 downsides to the current solutions: 2.1) They are per project customizations, there is no standard way to do this, 2.2) Without fbcon, no text output is possible at all and if something causes the GUI to not load there is no way to show a message to the end user (who will not have serial console access).

My work offers a standardized way to achieve the desired boot experience while keeping fbcon enabled so that error messages can be shown at any stage if necessary.

The GNU Affero General Public License (AGPL) is an important tool for protecting user freedom on the network. Detractors have criticized it for being both too weak and too strong/demanding. In 2018, it was in the news more than ever. Are the interests of corporations that are afraid of their free code being turned into network services run by competitors starting to align with users losing their freedom to such services?

Historically, the AGPL has been the target of criticism from entities that want to extinguish it. Some companies have banned it from their premises, sowed fear about how it operates, and propagated a myth that nobody is using it.

Others claim that the AGPL is being used primarily by companies seeking to strong-arm downstream users into purchasing a proprietary version of the covered software -- by catching those users being out of compliance with the AGPL, and telling them that they must buy the software under a proprietary license to avoid being taken to court for copyright infringement.

A third group of companies is now claiming that the AGPL doesn't go far enough to protect their software against being turned into services that deny users freedom -- though freedom may not be their primary concern.

In fact, the AGPL is being used today by a variety of interesting and important projects, including ones started by governments, nonprofits, and even businesses. I'll highlight some illustrative examples. I'll also do my best to separate understandable concerns that people have about using the AGPL from attacks on user freedom masquerading as concerns, and see if there is any synergy between the concerns of the third group above and those of individual users.

While not a full solution to the problems raised when users replace software running on their own machines with software running on someone else's machine, the AGPL is a tool that is being embraced and should be embraced even more.

Dark Peak is a user-run co-operative providing hosted open-source software for the benefit of our members.

This is the story of how some geeks from Sheffield are working together to free their data from the tyranny of global corporations!

We each want better control over what we share online and how our data is used, so we founded an organisation democratically run and owned by its users. By sharing resources and expertise, our volunteers aim to provide convenient alternatives that put you back in control, according to our four main principles:

1. Data with representation
2. Promote the dignity of data ownership
3. Provide the freedom to host some or all services yourself
4. Federate and interoperate where possible

This talk aims to give an overview of our organisation and how we came to be, what choices we made and why we made them and the mistakes we made along the way -- we want to share what we've learned from both organisational and technical points of view.

We hope the audience will be enthusiastic about self-hosting, and are interested in seeing the power of running or joining a self-hosting co-op.

Web application security is often underestimated, and using a secure framework can help reduce application vulnerabilities. Ada Web Application (AWA) is a web framework that leverages Ada's safety features to provide a secure environment on top of which safe applications are built. AWA is based on several Java-like technologies such as Java Beans, Java Servlet, Java Server Faces, other standards such as OAuth2, REST and OpenAPI, all implemented in Ada.

This presentation briefly describes the AWA architecture and how applications are built with it. The presentation highlights some of the Ada functionalities that contribute to the safety and make applications secure and reliable.

Kodi (formerly XBMC) is a free and open source media player application developed by the XBMC/Kodi Foundation, a non-profit technology consortium. Kodi is available for multiple operating-systems and hardware platforms, featuring a 10-foot user interface for use with televisions and remote controls. It allows users to play and view most videos, music, podcasts, and other digital media files from local and network storage media and the internet.

This meeting is for everyone interested in our project and community - as user, developer, or just to get an idea of what Kodi is all about. Several Team Kodi members will be present to chat with at your leisure.

In this presentation, we introduce PennyLane, a Python-based software framework for optimization and machine learning of quantum and hybrid quantum-classical computations. PennyLane’s core feature is the ability to compute gradients of quantum circuits in a scalable way that is compatible with classical techniques such as backpropagation. PennyLane extends the automatic differentiation algorithms common in optimization and machine learning to be compatible with quantum and hybrid computations. The library provides a unified architecture for near-term quantum computing devices, supporting both discrete- and continuous-variable paradigms of quantum computation. A plugin system makes the framework compatible with any gate-based quantum simulator or hardware, including leading quantum software platforms such as Xanadu's Strawberry Fields, IBM's Qiskit, and Rigetti's PyQuil. PennyLane can be used for the optimization of variational quantum eigensolvers, quantum approximate optimization, quantum machine learning models, and many other applications.

This session is for those MySQL DBAs and users who found some wrong, erratic, undocumented behavior while working with MySQL or MariaDB, got it crashed or failed in a way they consider totally wrong. We discuss what details to collect and provide, what tools to use and what steps to perform to create a public bug report that is processed (and, hopefully, fixed) fast. Possible efficient ways to escalate bugs that do not get proper attention are also presented.

This session is for those MySQL DBAs and users who found some wrong, erratic, undocumented behavior while working with MySQL or MariaDB, got it crashed or failed in a way they consider totally wrong. We discuss what details to collect and provide, what tools to use and what steps to perform to create a bug report that is processed (and, hopefully, fixed) fast.

We discuss current life cycles of MySQL and MariaDB bugs, details of practical bug trackers usage, approaches to "security" bugs and escalation procedures, formal and informal - everything to get a real MySQL bug processed, properly fixed and documented. All this based on my personal experience of 14+ years of bugs reporting, processing and prioritizing in MySQL, Sun, Oracle, Percona and MariaDB Corporation.

If you're joining us in the Mozilla devroom, you're likely already passionate about some of the things Mozillans do to build a better internet, contribute to cutting edge technologies or to help teach and share knowledge. You may even have a favorite project in mind. In this talk we're going to look at a range of different volunteer and contribution opportunities across Mozilla projects that could use a little bit of TLC from you. We'll examine how volunteer efforts power these projects, what impact your contribution could make and talk about the impact volunteer efforts make across the web and the world.

In this presentation I'll explain how OpenBSD simplify your task if you want to setup a full-featured NAS.

In my case, the NAS has the following features: - full encryption file system - transfer via NFS (for Linux and BSD machines) and sshd - implement a time machine-like system for end users' files - how to backup this NAS on a 2nd disk and make sure we do not have bit rotation - implement Dnla to present to present the multimedia content of this NAS to any DLNA devices (TV, ...) - How to transform this NAS into a music daemon via the Music Player Daemon. Thanks sndio, this NAS is connected to a Cambridge Audio DAC and an HIFI audio system.

I'll share my expertise in terms of Hardware for such NAS.

I'll highlight how to implement all those features and how OpenBSD facilitates this setup.

A Wiki is a powerful tool to store and display information provided by users. In this presentation we will show how it can also show information from external applications and connect to external applications. Using macros and internal scripting language on top of the XWiki Open Source Wiki platform, we will show examples of data being displayed from external applications. Examples will include: Elastic Search, Matrix/RIOT, Nagios, Cacti, JIRA, Databases.

In this talk, I'll try to provide an overview of the RISC-V Trusted Execution Environment working group, and what we are working on.

A Trusted Execution Environment guarantees the integrity and confidentiality of code and data, ARM has TrustZone, Intel has SGX, and we are working on a similar spec for RISC-V. Our main tool is Physical Memory Protection (PMP) functionality of RISC-V (part of the Privilege spec) for isolating memory regions of the execution environment's hart (hardware thread) from the rest of the harts on the system. We are also working on a proposal for an I/O PMP hw block for providing similar memory isolation between the different devices on the system (bus masters). The goal is to provide a flexible and scalable solution, that can work from 32bit embedded devices without MMU, to large 64bit systems with virtual machines etc, and keep it as simple and RISCy as possible.

This proposed talk would focus on how Europe is taking the lead deploying and supporting Open Hardware technologies. Large enterprises are looking for best practices gleamed from hyper-scale companies like Facebook, Microsoft and Google who run highly efficient private and public clouds. The sharing of open hardware and data centre designs is a core strategy for these companies and the basis for the Open Compute Project (OCP).

The Open Compute Project (OCP) was started by Facebook in 2011 with the idea of delivering the most efficient designs for scalable computing through an open source hardware community. We believe that openly sharing ideas, specifications, and other intellectual property is the key to maximizing innovation and reducing complexity in technology components.

In this topical discussion we would discuss the recent research that highlights how efficiency plays a role in the data centre transformation from conventional gear to OCP and open source. We would provide specific examples of how local European VAR’s and Solution Providers are capitalising on the open hardware business model and how "Open Source Software deserves Open Hardware".

Having used Guile for the previous number of years and being an enthusiastic supporter of and occasional contributor to Guix, what's it like switching to Racket, a different but in many ways similar Scheme language, for the last year? What can Guile learn from Racket? What can Racket learn from Guile?

A new Garbage Collector interface has been introduced in OpenJDK 10, and has been further improved in OpenJDK 11 and 12. This talk will give a short sight-seeing tour through its design and its important interfaces and should give you an idea where to start, if you'd want to make your own Garbage Collector or want to get started with OpenJDKs existing collectors.

In this talk we will present an overview of the current design and implementation of the new wire protocol of Ceph, named Messenger V2, that aims to overcome the limitations of the current protocol.

In this talk we will present an overview of the current design and implementation of the new wire protocol (the protocol used for communication between pairs of daemons and daemons and clients), named Messenger V2, that aims to overcome the limitations of the current protocol. We will start by describing the current wire protocol design and pinpoint its limitations, which will pave the way to present the new protocol features. Then we will present the details of the new protocol design and talk about some of the possible future features that can be implemented by extending the base protocol.

Immutable infrastructure is a way to success, but what about the lifecycle of individual resources. This talk is about the evolution of resources, code structure, Terraform coding tricks, composition, and refactoring.

Your infrastructure almost always starts simply: few resources + few developers. As time goes it grows in all possible directions. You found your ways around grouping resources into Terraform modules, so what can possibly go wrong? (famous last words)

Over the time you feel that infrastructure is your new pet, but why? You are worried about the configuration drift, you are afraid of touching it, you are delaying things...

By the end of my talk participants will become more aware of principles related to management of Terraform resources, Terraform modules best-practices and some CI/CD principles applicable to infrastructure management and deployments.

Adobe Connect is a proprietary platform for virtual presentations, conferencing sessions and screen recordings. Recently, one of our customers has requested our assistance in migrating their content from Adobe Connect to Kaltura. We've released the project as FOSS [licensed under AGPLv3]. This session will cover the challenges we faced and the FOSS tools we used to overcome them.

During the session, we will review the steps the code takes in order to extract and process the data associated with an Adobe Connect recording [video and audio files, metadata, etc]. We'll walk attendees through our use of FFmpeg, Selenium, Mozilla's Geckodriver and OpenCV and demonstrate how they were harnessed for the purpose of migrating the content.

We will conclude with a live demo of the migration process.

Mgmt is a next gen config management tool that takes a fresh look at automation. It has tight integration with a number of virtualization related functionality. This presentation will demo our virt resource and other virtualization related features! We'll demo live scaling a cluster of virtual machines, hot swapping the cpu count dynamically in seconds, and automatic load adjustment of vm's. We'll also show some unique integrations of these virtual machines with the existing mgmt language functions. We'll include many interactive examples showing you how to build reactive, autonomous, real-time systems with vm's! Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

Mgmt is a next gen config management tool that takes a fresh look at automation. It has tight integration with a number of virtualization related functionality. This presentation will demo our virt resource and other virtualization related features! We'll demo live scaling a cluster of virtual machines, hot swapping the cpu count dynamically in seconds, and automatic load adjustment of vm's. We'll also show some unique integrations of these virtual machines with the existing mgmt language functions. We'll include many interactive examples showing you how to build reactive, autonomous, real-time systems with vm's! Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

A number of blog posts on the subject are available: https://purpleidea.com/tags/mgmtconfig/ Attendees are encouraged to read some before the talk if they want a preview!

Companies regularly use and contribute to FOSS. Most larger companies now employee internal staff who make policy decisions, recommend Tools, oversee license compliance, teach others about FOSS, and interpret community politics for the company. Different offices and departments usually differ in their approaches to managing, using, contributing to, and releasing FOSS. This second annual Open Source Program Office (OSPO) panel explores the different approaches companies have to FOSS.

The YunoHost and Internet Cube projects are driven by the existing complexity in deploying and maintaining a server providing basic services, such as mail and web applications. How realistic is it to fight for a free and decentralized internet if only an elite of technicians have the skill, knowledge and time to administrate and maintain servers ?

Since a few years, the intention of those projects is to solve this key issue by lowering the technical barrier of self-hosting and making it a common practice. YunoHost is a Debian-based distribution that provides a clean and simple web interface through which the administrator can deploy services and apps quickly and with limited technical knowledge. The Internet Cube is a low-cost ARM board, preinstalled with YunoHost and preconfigured with a VPN to bypass ISP's restrictions, making it a plug-and-play solution for people willing to start self-hosting.

In this talk, I want to emphasize the necessity to democratize self-hosting against the GAFAM hegemony. Then, I shall recap how YunoHost and the Internet Cube currently works and present the evolution of the projects over the last two years. I will conclude by making a call for feedback and contributors from the FOSS community.

In this talk we explore the devastating effects using object oriented antipatterns in go while building programs in a monorepo. We look at how we got here in Kubernetes, and how (several years later) we are still working on cleaning up the mess. We explore brilliant refactoring techniques developed because of the original mistakes in Kubernetes.

Unknown to most, Kubernetes was originally written in Java. If you have ever looked at the source code, or vendored a library you probably have already noticed a fair amount of factory patterns and singletons littered throughout the code base. Furthermore Kubernetes is built around various primitives referred to in the code base as “Objects”. In the Go programming language we explicitly did not ever build in a concept of an “Object”. We look at examples of this code, and explore what the code is truly attempting to do. We then take it a step further by offering idiomatic Go examples that we could refactor the pseudo object oriented Go code to.

If the anti patterns weren’t enough we also observe how Kubernetes has over 20 main() functions in a monolithic “build” directory. We learn how Kubernetes successfully made vendoring even more challenging than it already was, and discuss the pitfalls with this design. We look at what it would take to begin undoing the spaghetti code that is the various Kubernetes binaries built from github.com/kubernetes/kubernetes

The audience walks away feeling empathetic that they aren’t alone in their journey to writing idiomatic Go and is now equipped with strong refactoring techniques developed by some of the world’s top engineers for the Kuberentes project.

The talk introduces you to the concept of "layers" in ODF (Open Document Format), which is completely different from "layer" concepts in image processing. The talk will then explain the "layers" actually implemented in LibreOffice, which come from StarOffice. Finally the presentation shows the resulting challenges for developers to adapt LibreOffice to ODF.

This talk outlines a strategy for designing interactions that take advantage of novel technologies by combining research, design, prototyping and storytelling.

Current and future network standards (e.g Neighbour Awareness Networking) will allow faster and more convenient direct connections between mobile devices. This technology has the potential to enable new interactions and social dynamics, as phones become aware of each other's presence and can exchange large amounts of data in a fast and private way.

But how do we find out what is possible? And how do we design for it?

This talk draws on several examples and working prototypes to show how a multidisciplinary iterative process can lead to important insights and a broadened range of possibilities.

Both design and engineering are fundamental parts of this process, as a wide range of skills is necessary to (among other things) carry out research, understand the constraints of the technology, build prototypes while ensuring that they remain usable and focused, detect problems and opportunities, and inform the course for future exploration.

The FOSS GPU virtualization stack has never before seen as intensive progress as in the the last months. Virglrenderer started as a research project to investigate the possibility of creating a virtual 3D GPU for use inside QEMU virtual machines that allows the guest operating system to use the capabilities of the host GPU to accelerate 3D rendering and is now getting to a product level quality.

This talk will go through an introduction of the Open Source graphics virtualization stack, the security advantages, look at history of the project and at what is happening to take it to production level.

Finally, the future plan for the GPU virtualization stack will be shared, like the support to different versions of OpenGL ES and Vulkan on the guest side, improvements to the performance and security of the stack.

The MVC pattern has been one of the most important architectural patterns for server-side web development - it has been implemented and popularized by frameworks like Ruby On Rail or ASP.NET MVC. However, this pattern was traditionally coupled with object-oriented programming. In the talk, I will show how to reinvent MVC pattern, and structure your web application in a functional language - F#.

The talk will cover some brief introduction to F# - modern functional programming language running on .Net platform, show how to model MVC layers using functional composition, and at the end show some examples of applying MVC pattern with Saturn - opinionated, web development framework for F# which implements the server-side, functional MVC pattern

The OPNFV community has developed a comprehensive set of open source test tools and test methodologies for NFVIs and VM-based cloud platforms. With the proliferation of cloud native and edge computing, we need to think about how to evolve these tools to meet the requirements of emerging and future use cases. In this talk, we will give an outlook on how the OPNFV test tool ecosystem can address new use cases and challenges. The test tools in OPNFV are not just for NFV, but can be more widely useful. We will present the tools, and discuss how they can be extended to support new and existing usecases.

This talk is aimed at an audience that want to test their SDN/NFV deloyments (but not necessarily using OPNFV). It will give an overview of the test tools, and how they can be use tools for many different deployments, test different components of your system (VIM, vswitch, storage, etc.) and perform different types of testing (infrastructure verification, feature validation, stress and resiliency testing, performance benchmarking, characterization, etc.).

In this session, the speaker will talk about how MyRocks's online backups work. Both physical (myrockshotbackup) and logical (mysqldump) backups will be covered, and physical backups will be more focused. MyRocks (and RocksDB)'s physical backups basically work by 1. invoking RocksDB checkpoint that creates hard links then 2. copying data files (SST), redo logs (WAL) and others. myrockshotbackup has additional features like "renewing checkpoint" that makes replication catchup shorter, streaming backups, and auto-detecting O_DIRECT. Logical backups in MyRocks/RocksDB is more efficient than InnoDB because RocksDB more efficiently keeps track of transaction histories. How physical/logical MyRocks/RocksDB backups work are not widely discussed in public, and the speaker will demystify in this session.

In this session, the speaker will talk about how MyRocks's online backups work. Both physical (myrockshotbackup) and logical (mysqldump) backups will be covered, and physical backups will be more focused. MyRocks (and RocksDB)'s physical backups basically work by 1. invoking RocksDB checkpoint that creates hard links then 2. copying data files (SST), redo logs (WAL) and others. myrockshotbackup has additional features like "renewing checkpoint" that makes replication catchup shorter, streaming backups, and auto-detecting O_DIRECT. Logical backups in MyRocks/RocksDB is more efficient than InnoDB because RocksDB more efficiently keeps track of transaction histories. How physical/logical MyRocks/RocksDB backups work are not widely discussed in public, and the speaker will demystify in this session.

Come hear how you can avoid giving your documents to a large proprietary company - and yet enjoy powerful collaborative editing of text documents, spreadsheets and presentations.

Come hear how you can avoid giving your documents to a large proprietary company - and yet enjoy powerful collaborative editing of text documents, spreadsheets and presentations.

Hear how you can host that yourself, integrated into various other FLOSS projects. See how the code is structured - bringing the full power of LibreOffice's rendering and interoperability, along with an increasing amount of our feature surface to the browser.

See some demos of it in action. Hear how you can get involved with development, build a rich integration via scripting and integrate this with your own online solution.

Hear about our relatively simple collaboration protocol, the thinking behind it, and the great privacy, security, and even some performance benefits it brings vs. traditional multiple-model, streamed composable operation approaches.

Skulls makes it easy to install an unlocked, up-to-date and easy to use coreboot-based BIOS on your laptop. It should be a starter drug to more advanced systems like Heads.

Fractalide is a Flow-Based Programming framework for making GUI applications in Racket and Rust, tied together by Nix. As one of the first applications to make use of this, we created Cantor, a cryptocurrency wallet.

How did using Racket help us or hinder us, and how does Flow-Based Programming interact and fit with Functional Programming?

Many language runtimes like the JVM rely on JIT compilation to improve application performance, but JIT compilers actively compete with applications for CPU and memory resources. Because of this, a JIT compiler's activities may hinder application throughput and create performance hiccups that can affect quality of service while also complicating resource provisioning. On top of that, it takes a while even for the best JIT compilers to fully compile the performance critical methods of an application to deliver the steady state performance we all expect from the JVM. An approach we are exploring is to decouple the JIT compiler from the rest of the JVM so that JIT compilation can operate as a separate, remote service. This approach opens up the possibility of an elastic, cloud based service offering JIT compilation for many applications, languages, and even different architectures simultaneously.

In this talk we will present our experience building an open source JIT-as-a-service prototype based on the Eclipse OpenJ9 JVM. We will discuss some of the engineering challenges we encountered, demonstrate the advantages we've seen thus far, and present performance data for enterprise grade Java EE benchmarks.

Webhooks are the natural evolution of modern applications beyond using APIs to integrate between systems. This talk will showcase the webhook examples you're already familiar with, and show you how to handle these features in your own applications.

In an increasingly connected world, APIs are key to great tools and effective workflows. What is better than an API? A webhook of course! Webhooks are the modern way for integrating systems and allowing them to react to one another. This session will cover what a webhook is, when you might want to use one, and some examples for handling webhooks in your own PHP projects. You'll see some examples of tools to help during the development process, and some real examples of webhooks in action.

Google is a world leader in technology and a major contributor to a number of open source efforts. Google's quantum hardware and algorithms teams have achieved a number of quantum computing "firsts". This talk will present the Google quantum computing architecture, an update on current hardware implementations, and a description of the design and philosophy of Cirq, Google's open source programming language for near term "NISQ" (noisy intermediate-scale quantum) computers.

This talk will be about establishing good ethical guidelines and standards for user research for the SecureDrop project. The 2 speakers have contributed to SecureDrop, an open-source software platform for secure communication between journalists and whistleblowers.

This talk will be about how we established good ethical guidelines and standards for user research for the SecureDrop project. The 2 speakers have contributed to SecureDrop, an open-source software platform for secure communication between journalists and whistleblowers.

It will focus on why ethical research is important in user-centred design, how to do ethical user research in open source projects. It will also explain how to establish a trusting relationship with participants.

UEFI is a replacement for the BIOS. It supports Secure Boot which is signature verification of bootloaders and OS kernels which helps prevent attacks where malware injects itself into the bootloader or kernel so that it can be loaded during startup. Despite the poor reputation that Secure Boot has in the free software community (mostly due to non-technical reasons), this would be useful to have for VMs running on Xen. It is also required for features in guests such as Windows Credential Guard. This talk describes how Secure Boot support has been added to Xen.

Xen has long had support for running guests booted with UEFI using a build of edk2/Tianocore built for VMs called OVMF.

Systems that use UEFI boot have a small amount of NVRAM that stores variables critical for booting the system. Secure Boot is built upon the concepts of authenticated variables and a set of keys. Authenticated variables require updates to be signed by particular keys. These keys themselves are stored in authenticated variables.

Verifying updates to authenticated variables needs to be performed in a way that cannot be tampered with by the guest which may have been infected by malware. There are a few ways of dealing with this. The talk will look at the approach taken by bare metal, KVM, and finally how we have implemented it for Xen. This is done by introducing a new component called varstored which runs outside of the context of the guest. It acts as an interface to the guest's NVRAM and verifies updates to it. Actual storage of the NVRAM is delegated to a number of backends to support different uses cases. For example, for a single host it could store the NVRAM in a simple file. For a pool of hosts it could store the NVRAM in database server accessible poolwide.

Traditional NFVi dataplane performance testing rarely focuses on (availability, consumption) dark resources such as CPU Cache and Memory Bandwidth. Much of the Quality of Service fine tuning often leads to oversubscription ending up with shared resource contention often termed as noisy neighbor effects. We present the methodology and test scenarios using open source solutions - OPNFV-VSPERF Framework, Collectd monitoring solution, Stress-NG workload generator and Resource Management client for (a) analyzing the performance impact due to presence of noisy neighbors and (b) controlling resources like Last Level Cache (LLC) for optimal performance. This talk was presented at recent Open Source Summit.

Short Bio: Sunku Ranganath is a network software engineer in Intel Corporation, focused on enabling service assurance solutions for SDN/NFV infrastructures. With background in drivers & firmware development, Sunku has been actively involved in enabling reference solutions, performance methodologies and industry guidance in the NFV domain. Sunku is also an active contributor and user of OPNFV barometer & VSPERF communities.

This is a BoF on the status of Free Software on a mobile device using the Purism L5 phone. Members of the development team and community members who have dev kits will gather today to talk about we will develop software for the Librem 5, Q/A from the audience, and a small part of time flashing some dev kits for dev kit owners.

We would like to invite developers for a round table to discuss the specificity of the organization of decentralized software, and to address organizational issues that are crucial for the survival of the projects we love.

F/LOSS development is often mostly organized along a the sequence of its commits, while the idea that a great software starts with one person,is a quite common narrative in F/LOSS (think about linux or git). Even community-led projects often tell their history centering it on one hero (see for example the history of open street map: https://wiki.openstreetmap.org/wiki/HistoryofOpenStreetMap). So what about decentralized software? From a feminist standpoint we are not satisfied with the "hero narrative", as we feel it doesn't fully represent the complexity and the values of decentralized software projects. Furthermore, this narrative can be detrimental for the long term sustainability of decentralized projects because it can overshadow the importance of thinking about organizational problems and community health. Instead, we would like to invite developers for a round table to discuss the specificity of the organization of decentralized software, and to address organizational issues that are crucial for the survival of the projects we love. How to build and sustain projects which are not only decentralized from a technical perspective, but also from an organizational one? How to share responsibilities so that code and infrastructure work but people do not burn out -making entire projects at risk to disappear? And how to tell if a project is anyway destined to disappear or if there is an organizational bug which can be fixed? During this roundtable we wish to invite developers from Fosdem's decentralized room to discuss those issues but we are still in the phase of contacting them.

Clang plugins in LibreOffice - global analyses across a large codebase

In the old days, we expended considerable effort to make our global analyses more efficient, especially when dealing with large codebases like LibreOffice. However, with the advent of modern hardware and software tools this has become largely necessary.

This talk will focus on some pragmatic design choices that lead to being able to run global analysis passes across the LibreOffice codebase, without breaking the bank on hardware or waiting days for results.

Also, I discuss gradual approaches to developing such plugins that do require language-lawyer level knowledge of the C++ AST.

In this talk we'll see how to build a toy using off-the-shelf hardware (Raspberry PI and Mir:ror), the various explorations that led to this creation. How we moved from a shell and AWK prototype, to a Go program, removing many bugs and races in the process. Then, we'll see how we used gokrazy to remove most of the non-go userspace, and move from raspbian to a custom, pure-go distro.

This talk is a continuation of the awk driven IoT blog post, in which I explained how I explored various toy concepts with awk and shell scripts. Once I found a working concept, I decided to rewrite it in Go to fix race conditions, and ease adding new features. I'll show the challenges of this first step: how to drive an external program (mp3 player) with context and goroutines, while simultaneously getting events from the hardware NFC reader.

Then I'll show how to convert the raspbian image with a systemd service, shell, etc. to a gokrazy image; first using the breakglass escape hatch to have a minimal working solution, then solving the various parts that can rely on external dependencies, in order to achieve a real pure-go userspace: using a custom mp3 decoder, handling the alsa audio output, using the proper HID device, etc.

We'll finish with a demo of the working device, the lessons learned, and a small suprise at the end.

Describe a system of using ZFS Boot Environments to quickly, safely, and atomically upgrade 100s of remote machines.

Overview: * How the file system hierarchy is modified to allow the systems to be upgraded in-place * How we use ZFS to create and deploy the boot environments * Simplifying the creation of the BEs using poudriere image * Extending poudriere image to support ZFS * Using zfsbootcfg to boot a new BE once * How we determine if the BE “works” and should be promoted to the default

Motivation: * We often have only SSH access to the machines, so we needed something that could self-recover just by power cycling the machine * No longer need to use freebsd-update, mergemaster, or etcupdate

This talk is about a library written to help manage a fleet of bare metal servers, it leverages existing (mostly undocumented) APIs on Baseboard Management Controllers, and exposes a consistent API interface to,

• Inventorize bare metal hardware
• Manage BMC/BIOS configuration
• Reliably Power cycle/PXE boot bare metal.
• Update firmware on BMCs

https://github.com/bmc-toolbox/bmclib

This talk is about bmclib, a library written to perform asset lifecycle management, across a fleet of bare metal servers, it leverages existing (mostly undocumented) APIs on Baseboard Management Controllers, and exposes a consistent API interface to,

• Inventorize bare metal hardware
• Manage BMC/BIOS configuration
• Reliably Power cycle/PXE boot bare metal.
• Update firmware on BMCs

https://github.com/bmc-toolbox/bmclib

While all of the above seems obvious functions of bare metal server hardware that should just work, in reality they do not - when dealing with ~45k units of bare metal server hardware from various vendors, this is a lesson we learned and hence we developed bmclib and all of the various tools that is part of the bmc-toolbox.

https://github.com/bmc-toolbox

We intend to talk about the current state of BMCs, the current vendor solutions to have a single API (Redfish) and the various tools that are part of the bmc-toolbox which were possible thanks to bmclib.

Another interesting project (which we intend to talk about) was to implement a service on top of bmclib to retrieve thumbnails from the BMC, of the screen of the server and run image classification on it to infer what state a bare metal is currently in, thanks to bmclib this was easy since we implemented a common method to grab "Screen previews" through the BMC.

The bmc-toolbox is built and maintained in Booking.com.

About a year ago the PostgreSQL community discovered that fsync (on Linux and some BSD systems) may not work the way we always thought it is, with possibly disastrous consequences for data durability/consistency (which is something the PostgreSQL community really values).

I'll walk you through fsync basics, explain how we always thought/assumed it works and how it actually behaves. I'll also discuss where the misunderstanding likely comes from - which is a mix of cultural and technical reasons rooted in the past. We'll see how this issue impacts current PostgreSQL deployments, what you can (and can't) do about it, and finally outline some plans for addressing it properly in the future.

Developers generally enjoy increased productivity when working in a managed code environment. What might not be obvious to them is the amount of investment in the managed code’s Virtual Machine to enable both productivity and high performance. Microsoft’s .NET team would like to share how they designed the runtime environment to balance convenience, fast startup, serviceability, low latency, high throughput. For examples services such as JIT compilation, TypeSystem, garbage collection all provide convenience but come at a cost. The challenges presented are common to many environments – you do not need to be a .NET developer to attend this talk.

If you are a .NET developer, you can leverage the tools demo in this talk to tune your application as well.

Imagine you have a fantastic Ada program or library but you want more! You want it to be scalable and used by other developers with other languages. The goal of this presentation is to show you the way to achieve it without bending to fashion. :) As of today, we see distributed computing as Web services, mainly RESTful stuff. Some technologies exist since years and are working successfully in many systems. One of these is CORBA which allows Object-Oriented communication between applications in languages such as Ada or C++.

In this presentation, the chosen middleware providing CORBA infrastructure is PolyORB. We will use it to make a distributed version of an existing piece of software, the Corporate Bullshit Generator (CBSG), and create client applications in C++ and Ada. This will allow us to put the power of Ada and PolyORB into a distributed system.

Security is and has been a hot topic in recent history. Software and hardware systems are increasingly complex, vulnerabilities increasingly publicised and attack methodologies increasingly sophisticated. This trend began long ago as did efforts to design and implement foundational technologies to curtail it. The trusted platform module (TPM) is one such technology. It was specifically designed to thwart attacks that aim to steal or misuse sensitive cryptographic keys. Despite its obvious benefits, TPM adoption on OSS platforms was historically minimal.

The next iteration of TPM implementations (TPM2) is quickly reaching critical mass in consumer computing platforms. Aiming to capitalize on the availability of TPM2 hardware, the tpm2-software organization on Github (https://github.com/tpm2-software) has coalesced as a community around the implementation of the TCG standard APIs, and their integration into common software tool and infrastructure. This talk will start with an overview of the tpm2-software community, it's history, it's current direction and how new users can get involved. The talk will then shift to discuss the technical details of the TPM2 software stack (TSS2) infrastructure and programming APIs and our current efforts to improve the security properties of OSS through their adoption. Finally, we'll conclude by presenting a use case driving the implementation of a new TPM2 Command Transmission Interface (TCTI) module enabling use of the TPM2 from with the SGX trusted execution environment.

Security is and has been a hot topic in recent history. Software and hardware systems are increasingly complex, vulnerabilities increasingly publicised and attack methodologies increasingly sophisticated. This trend began long ago as did efforts to design and implement foundational technologies to curtail it. The trusted platform module (TPM) is one such technology. It was specifically designed to thwart attacks that aim to steal or misuse sensitive cryptographic keys. Despite its obvious benefits, TPM adoption on OSS platforms was historically minimal.

The next iteration of TPM implementations (TPM2) is quickly reaching critical mass in consumer computing platforms. Aiming to capitalize on the availability of TPM2 hardware, the tpm2-software organization on Github (https://github.com/tpm2-software) has coalesced as a community around the implementation of the TCG standard APIs, and their integration into common software tool and infrastructure. This talk will start with an overview of the tpm2-software community, it's history, it's current direction and how new users can get involved. The talk will then shift to discuss the technical details of the TPM2 software stack (TSS2) infrastructure and programming APIs and our current efforts to improve the security properties of OSS through their adoption. Finally, we'll conclude by presenting a use case driving the implementation of a new TPM2 Command Transmission Interface (TCTI) module enabling use of the TPM2 from with the SGX trusted execution environment.

In the past year a lot of work has been put into improving the V4L2 subsystem. The main addition was the Request API, which is required for stateless hardware codecs, and will help improve complex camera pipelines. Codecs in general saw a lot of attention and our virtual drivers are now being used in test frameworks. So it is time to present an overview of the current state of V4L2 and what can be expected from it in the future.

XWiki's advanced features for structuring data and scripting in wiki pages make it suitable for developing applications of various sizes, for various needs. The wiki principle make all these applications collaborative by default, while the multiple UI configuration options and permission system allow to show as much or as little of it as needed for the specific case . In this talk I will explain the usage of XWiki through the angle of comparing its usage with the development of applications from scratch. I will explain and demo the various features of the XWiki platform and how they can be assembled together to create applications and show some examples of such work that was done for professional accounts (e.g. https://nosdemarches.gouv.fr ).

TiDB is an open source distributed scalable hybrid transactional and analytical processing (HTAP) database built by PingCAP. It also speaks the MySQL protocol and uses RocksDB as the underlying storage engine!

This talk provides an introduction and overview of TiDB, tailored for those with a strong background in MySQL. I will use MySQL as an example to explain various implementation details of TiDB, and translate terminology to MySQL/InnoDB terms.

At the GNU Tools Cauldron, my colleague, Jeremy Bennett, showed how the long established GNU tool, CGEN, can be used to create an assembler, disassembler and simulator from a semi-formal description of the RISC-V architecture in Scheme (https://gcc.gnu.org/wiki/cauldron2018#cgen).

However the CGEN specification in Scheme is far from rigorous by today's standards. Alastair Reid of ARM has shown how SAIL can be used to define rigorous semantics for RISC-V in a paper to be presented at POPL in January 2019 (https://alastairreid.github.io/papers/POPL_19/).

In this talk I shall show how a SAIL specification can be transformed into a CGEN framework. Using this approach, a rigorous SAIL semantic specification can be used to generate a practical GNU assembler, disassembler and simulator.

This will is a work in progress - the project is not due to finish until May 2019. I shall explore the general approach used, and the areas where the greater rigour of SAIL runs into problems with the limitations of CGEN Scheme specification.

Monitoring involves dynamically extracting, disseminating, interpreting and presenting system information to the user. The advent of distributed storage environments brings in new challenges to the monitoring world. Going through logs of a large volume of data over geographically distributed nodes simultaneously to detect the point of failure is becoming infeasible and time-consuming. There is a dire need to replace the standard monitoring techniques and practices used to monitor centralized storage with a centralized monitoring system, which obtains exact information required to track the health, performance, load and capacity of system objects or software processes in the distributed systems and present it to the users in real time and in useful formats.

In this talk, Rishubh and Gowtham will discuss the challenges faced by sys-admins in monitoring distributed systems and will discuss how tendrl an open source monitoring tool aids them in monitoring a distributed storage system with the help of a scale-out open source software defined storage (SDS) - Gluster. You will get an in-depth explanation on how tendrl monitors each system in the distributed environment and get a glimpse of its modern web interface. They will also show the audience how metric virtualization provided by grafana makes monitoring rudimentary and fast. Their talk will conclude with a demo on how tendrl helps vendors in capacity planning, detecting and alerting the failure conditions, and keeping track of performance and health of the system.

Monitoring involves dynamically extracting, disseminating, interpreting and presenting system information to the user. The advent of distributed storage brought in a lot of new challenges in monitoring the storage systems. It has become impractical for the sys-admins to go through logs of each storage systems distributed across geographically dispersed nodes to detect points of failure. It’s also infeasible to keep a track of health, performance, and capacity of each system by tracking logs obtained via fetching information over terminal using CLI commands.

In order to monitor the environment efficiently, the monitoring system should be able to get information about each component on every node in the distributed storage environment. Gathering so much data can flood it with a lot of information all of which is not required by the user. The monitoring system should be able to filter the information and display only relevant information to the user when it’s required.

Monitoring should:

1. Help users find out why and when did their system fail?
2. Help users to predict future problems.
3. Help users make decisions based on real data and trends instead of hunches.
4. Avoid outage costs.
5. Observe and check the status of processes and resources over a period of time and keep them under systematic review.

Tendrl facilitates:

1. Monitoring distributed storage system with ease.
2. Operational consistency and efficiency (streamlined provisioning, enhanced discovery, and management via the integrated service dashboard).
3. Getting important information about storage utilization to help troubleshoot and diagnose issues (noisy neighbor, flaky disks, network bottlenecks)
4. Proactively monitor and manage health, performance, and capacity utilization and gain operational intelligence at scale. Receive alerts for operational issues requiring intervention.
5. Alert on operational issues: (OSD state, Cluster state, Failed Drive etc)

For better understanding, in the presentation we also include interactive demos that show the challenges faced by users and how they can overcome these challenges.

With the proliferation of OpenJDK binaries for a developer or a business to choose from, one factor in determining the selection is quality. How do you know your choice is up to snuff? The AdoptOpenJDK Quality Kit is an open and transparent verification story for OpenJDK binaries. A robust and adaptable test kit that can be utilized by any OpenJDK implementor, and represents the quality bar required by large-scale customers in enterprise environments. We test multiple freely available JDK implementations at AdoptOpenJDK and continue to refine this suite of tests to give the community access to high-quality binaries.

Beyond a frank discussion starter on the criteria by which we measure quality, this talk summarizes the real quality requirements of enterprise customers and presents a compelling story for verifying and/or selecting your OpenJDK implementation.

You always wished you could have a language that explains perfectly what you are trying to do? You find yourself constantly waiting for your favorite programming language to add a feature? Why not doing it yourself? Come at this workshop and try making your own language using Racket, the language-oriented programming language! (did I say "language" twice?)

This workshop will quickly describe how to use the Racket language, then dive into making your own language. I should be able to handle between 3 to 5 people at a time. Session duration should range from 1 hour to 1.5 hours.

Maemo Leste is community a Debian/Devuan based GNU/Linux distribution for smartphones and tablets aimed at free software hackers. In spirit and look it is similar to the Maemo Fremantle OS for the famous Nokia N900 phone. This talk will present the current (alpha) state of Maemo Leste, the presently supported devices, our development setups, the present and upcoming challenges and lay out the future plans for software and hardware (device) support.

This lecture will introduce Maemo Leste, a free Debian/Devuan based GNU/Linux hacker distribution for smartphones and tablets. We will cover the history of Maemo and explain what drove us to work on and create Maemo Leste.

We will provide a technical overview of the software stack, show off and discuss the current status software stack, how we got there, our upcoming milestones and the challenges that lie ahead.

Additionally, we'll take some time to discuss the "hacker" aspect of Maemo Leste. such as (only) supporting mainline Linux, future (first class) Tor and Wireguard integration, bleeding edge open GPU drivers and the availability of all the packages of Debian.

Next to that, we will explain the development setups, build servers and infrastructure, provide some information on how to port Maemo Leste to a new device, dive into possible Android compatibility and hardware and driver issues difficulties (such as mobile GPU drivers and the current open source solutions).

Resources:

• Website+News: https://maemo-leste.github.io/
• Github: https://github.com/maemo-leste
• Wiki: https://leste.maemo.org/
• Nokia N900 status of Maemo Leste: https://leste.maemo.org/Nokia_N900
• Motorola Droid 4 status of Maemo Leste: https://leste.maemo.org/MotorolaDroid4
• Lima driver (Linux 4.19 + patches) running Maemo Leste on Allwinner A33 tablets: https://www.youtube.com/watch?v=ihCVsaEMNzY

dpdk-burst-replay is a friendly tcpreplay tool for DPDK NICs, main objective being to operate as fast as possible (similar to --topspeed option of tcpreplay). To achieve this, it pre-load the pcap file on memory before sending it to the Tx queues. It can send the packets simultaneously through multiple ports (with dedicated threads), and several times in a row.

We will start with an overview of what it can do, what it is made for, then we will see how to use it on a typical use case: setting up a stress test between several NIC ports with pcap dumps of real traffic. Finally, we will talk about how it was designed, how it should evolve, and what features we would like to add.

A quick review of new features of CSS that came widely available in 2018 or are about to come in 2019. Some of these features were already present but have matured enough to e used by Web Developer

We propose a workshop on the usage of the various software of the ossia ecosystem (https://ossia.io), which are a set of tools to be used in a creative coding context, in order to create art, in particular shows, artistic installations, or museum exhibitions.

We will present the usage of two tools. First, the library libossia (https://github.com/OSSIA/libossia), which allows exposure and control of the parameters of a creative software over the network across many different languages and environments (C++, Java, C#, PureData, Python, SuperCollider, Qt/QML, Faust...). Then, we will show and teach the usage of the software ossia score (https://github.com/OSSIA/score), which allows to score the parameters of these creative applications in time, as well as include media, sound effects, hardware peripherals, robots, DMX lightning, etc. In particular, the interactive features, which allow for non-interactive timelines and scoring will be showcased and explained.

The OSCQuery protocol will be discussed (https://github.com/Vidvox/OSCQueryProposal). It has been conceived in collaboration with the authors of multiple industrial-grade media software companies such as VDMX, Vezér, Millumin and others. This protocol is implemented in libossia and allows extensive interoperability amongst this kind of software, in particular between websites and traditional desktop software thanks to the use of WebSockets.

The Yoast design team explains how they went from individual designers to a design team, to having a weekly design meeting, building a design system, and how this is preparing them to standardize and open source their design philosophy.

Open Source is a great philosophy, but for designers it doesn’t necessarily feel like a natural fit. Even at Yoast, which lives and breathes open source, the design team has had their struggles with this - and still does to this day. We have a strong brand identity that lives in our shared consciousness, but how can we explain this well to a new team member, or someone outside the design team, or even outside the company? In this talk, we’ll talk about the process we went through to get our designers to think outside their own heads, and the way we're creating a shared vision through the ‘Yoast Design Meeting’.

Native GTK Dialogs, current status and future work

This is a proposal to give a presentation about PipeWire and the current state of affairs. See also https://pipewire.org

This panel gathers standard authors and implementors of ActivityPub to discuss the role of ActivityPub in the present in connecting together the fediverse and what the future might hold.

When people think of the interaction between patents and open source, the most frequent questions have to do with the existence and scope of patent licenses, either express or implied. However, patent exhaustion may end up being far more impactful than licenses. This discussion will present the results of some recent analysis of the caselaw and discuss some of the unexpected implications of recent patent exhaustion cases.

A patent gives its owner the right to exclude others from making, using, and selling the claimed invention. In contrast, FOSS licenses grant broad rights to modify, compile, distribute, and use software. Absent explicit treatment in the license, the patent-related right to exclude and the open-source-granted right to use are at least apparently in tension. One of the ways in which this tension is addressed is through the doctrine of patent exhaustion. An analog to copyright's "first sale" doctrine, any authorized sale of a patented object by a patent owner or a licensee exhausts all patent rights in the product sold, which prohibits a patent owner from enforcing post-sale restrictions through patent infringement suits.

It is uncontroversial to say that patent exhaustion applies to FOSS. A patent holder that "sells" a software product, or sells a physical product with with FOSS software embedded, will clearly be subject to patent exhaustion as applied to any downstream customers of the patent holder. But that is not the end of the analysis. What does it mean to "sell" a "product" sufficiently to invoke patent exhaustion? How does that correspond to the normal ways in which organizations typically interact with FOSS?

This presentation will quickly go through the essential holdings from five cases[1], and then present an argument regarding how the holdings of these cases interact with typical FOSS practices in a far more extensive fashion than people may have previously considered.

[1] Cases: * Quanta Computer, Inc. v. LG Electronics, Inc. * Impression Products v. Lexmark International * Lifescan Scotland, Ltd. v. Shasta Technologies * Cascades Computer Innovation, LLC v. Samsung Electronics Co. * Intel Corp. v. ULSI System Technology, Inc.

Ansible, the familiar IT automation tool, makes it easier than ever to automate your Kubernetes cluster. This talk introduces two practical ways to define and provision complex applications using Ansible Automation with Kubernetes.

Have you longed for a simple yet powerful way to automate workloads on Kubernetes? Ansible, the familiar IT automation tool, makes it easier than ever to automate your cluster. This talk introduces two practical ways to define and provision complex applications using Ansible Automation with Kubernetes.

The Automation Broker allows users to leverage Ansible Automation to define and orchestrate applications, making them available for self-service provisioning in the Service Catalog.

The Ansible Operator allows users to actively manage the full lifecycle of an application by defining management behaviors with Ansible; the Operator handles everything else.

In this session you will learn: How to define and deploy your application on Kubernetes using Ansible. How to publish your own applications in the Kubernetes Service Catalog. How to create a Kubernetes Operator using Ansible.

Writing Ada bindings for C and especially for C++ is a tedious but not necessarily sophisticated task. There are several approaches to both C and C++ but many of them lack desired language features, generate non-compilable code or are project specific.

With Cappulada (a coinage of coupling, CPP and Ada made pronounceable) we try a more general approach that aims to support complex language features such as templates or inheritance while providing a semantically appropriate mapping of object structures and types. The talk will also cover which features can be mapped and what is not feasible or possible.

Creating a new virtualization platform in 2018 seems intriguing. Why doing something like this? Is anyone would be interested? XCP-ng answered those questions in a clear manner. Initially a fork of XenServer, XCP-ng made something some people thought would be impossible: gathering a large community around a new virtualization platform in those modern days, where containers and serverless are advertised as the only way to build a decent IT infrastructure.

XCP-ng is a fully Open Source and turnkey virtualization platform. In other words, a specialized Linux distro, with everything you need to run your virtual machines on it, without complicated installation and configuration. We'll see why it was born in the first place, what happened since and the future of it.

Come here our panelists discuss the past, present and future of open source .NET. There will also be opportunities to ask questions.

The Go runtime has a garbage collector (GC) which is famously simple and lacking in tuning parameters compared to, say, a JVM.

However there are controls, and in this talk we shall look at what they do and when you might use them. We will also look at how to understand what GC is doing and how much that work might be costing your program.

Primarily we will look at the GOGC environment variable, and how it can be used to increase or decrease the rate of garbage collection, or turn it off completely.

We will show how garbage-collection activity can be observed via metrics, e.g. using Prometheus, or in more low-level detail via the GODEBUG environment variable.

We will also look at the evolution of GC performance in Go over the last five years, and new controls being added in the next version of Go.

Over the years, more and more vendors have embraced DPDK to enable their NICs for userspace packet processing. This trend has advanced DPDK, leading to the development of new APIs with the aim of leveraging the heterogeneous features and capabilities of NICs. This level of diversity in PMDs and APIs is a catalyst for an inconsistent development environment, making it difficult for applications to accommodate all types of NIC. To overcome this, we propose DPDK SoftNIC, which is capable of being programmed to build custom NIC pipelines to augment missing features to HW NICs by using advanced DPDK features without requiring an application redesign. SoftNIC allows the application to be incognizant of the hardware available to it without compromising functionality.

"Serverless" is the one hot topic of the past years. "Serverless functions" can be incredibly useful and supported by all major cloud providers. I want to compare this to the beginnings of PHP and how we can do very similar things with low effort and without any super fancy tools.

"Serverless functions" are basically "functions as a service". But what makes this so special? And why did PHP do most of this from it's beginning? I want to show how things worked when I started with PHP >10 years ago and how similar this was to todays "serverless functions". How you can easily create specific endpoints that do one specific thing, without writing a single line of code that handles routing. Even without writing a single line of configuration. "Serverless functions" are something bold and awesome and new and fancy, but they are not es special as they might look on first sight.

The talk is supposed to be entertaining. I don't want to talk people into using "functions as a service" or into not using them. But it might be interesting to know where things came from and that PHP might have inspired this whole development of the past years.

Born in 2010 in MySQL 5.5.3 as "a feature for monitoring server execution at a low level," grown in 5.6 times with performance fixes and DBA-faced features, in MySQL 5.7 Performance Schema is a mature tool, used by humans and more and more monitoring products. It becomes more popular over the years. In this talk I will give an overview of Performance Schema, focusing on its tuning, performance, and usability.

Performance Schema helps to troubleshoot query performance, complicated locking issues, memory leaks, resource usage, problematic behavior, caused by inappropriate settings and much more. It comes with hundreds of options which allow precisely tune what to instrument. More than 100 consumers store collected data.

Performance Schema is a potent tool. And very complicated at the same time. It does not affect performance in most cases and can slow down server dramatically if configured without care. It collects a lot of data, and sometimes this data is hard to read.

This talk will start from the introduction of how Performance Schema designed, and you will understand why it slowdowns server in some cases and does not affect your queries in others. Then we will discuss which information you can retrieve from Performance Schema and how to do it effectively.

I will cover its companion sys schema and graphical monitoring tools.

You can run Android on a wide range of devices, not just phones and tablets. Building Android from scratch is fun and a great way to learn about the lower levels of the operating system. Imagine - here is a chance to create ANY Android configuration you want.

In this presentation, I will describe how to take a Raspberry Pi 3 and build Android completely from scratch, using source code from the AOSP (Android Open Source Project). One issue is finding an implementation of the OpenGL ES libraries and GPU drivers with the appropriate Android additions. Luckily, there is a cross-platform graphics layer called SwiftShader that we can use. Another pain point is that the Raspberry Pi doesn’t have a USB OTG port, so we can’t use adb in the normal way. No problem, we can use adb over Ethernet instead.

This presentation focuses on the Raspberry Pi, but in a similar way you can port Android to many other devices. If it can run Linux, there is a good chance it can run Android.

Ceph is a highly distributed software-defined storage solution. It provides allows you to store and access your data via interfaces for block, file and object storage. It aims primarily for completely distributed operation without a single point of failure, while being scalable to the exabyte level. Deployment and management of a cluster not rarely consisting of hundreds of nodes can be a challenge. That's why we, at SUSE, provide a salt based tool called 'DeepSea' that tries to help you manage your cluster with ease. We designed our product with scalability in mind so that our users don't have to care about the size of their data-center but can concentrate on the important tasks. This Talk will give a short introduction to DeepSea and highlight the new features we added.

Ceph is a highly distributed software-defined storage solution. It provides allows you to store and access your data via interfaces for block, file and object storage. It aims primarily for completely distributed operation without a single point of failure, while being scalable to the exabyte level. Deployment and management of a cluster not rarely consisting of hundreds of nodes can be a challenge. That's why we, at SUSE, provide a salt based tool called 'DeepSea' that tries to help you manage your cluster with ease. We designed our product with scalability in mind so that our users don't have to care about the size of their data-center but can concentrate on the important tasks. This Talk will give a short introduction to DeepSea and highlight the new features we added.

A talk about past changes and potential future changes in PostgreSQL and FreeBSD that aim to make this combination the best relational database platform.

PostgreSQL and FreeBSD have many things in common, including ancestry at Berkeley, similar project structures and a pesky more popular rival. The talk will cover some recent changes made over the past years on both sides of the "wall" to improve the performance and user experience of this pairing, some ongoing work and many ideas for future improvements. In many cases it's a matter of catching up with Linux, and in others it's entirely new possibilities. The talk will finish with a question: "what would you change if we could change anything?", because, well, we can!

With the new more rapid cadence, improvements are coming to Java faster than ever. Join Java Language Architect Brian Goetz on a whirlwind tour of some of the features that are coming to Java in the coming months and years.

A journey over the last ten years of opening access to switching ASICs. Starting with OpenFlow going through the lands of open APIs we have reached the harbours of openness. Are we there yet to build a truly open Network Operating System?

Open Source got mainstream in the world of switching ASICs. We nowadays can get open access to steer multiple terabits of packets through the network. This talk tries to cover the path that startet ten years ago with OpenFlow that tried to open up the networking world. We will pass by some more or less known buzzwords like Indigo, OF-DPA, Switchdev, OpenNSL, SAI, P4, SDK-LT and NPL. From this zoo of lower level details we will have a look at their use in Network Operating Systems (NOS) today. Finally trying to answer the question: Are we there yet?

Are you also annoyed that it is 2019 and you still have to bookmark stuff? Or that your notes about your web research are scattered everywhere? How come we cannot really collaborate and communicate in our web-research? In this talk we give a brief introduction into Memex. It's an open-source browser extension to organise your web-research. Full-text search everything you've seen on the web, archive and annotate websites and collaborate with your peers in your web-research. All data stored on your computer & self-hostable. With a mix of open-source software, data interoperability and a non-speculative economic model we try to protect users data sovereignty, privacy and stimulate the democratisation of knowledge management software.

An experimental project which uses web technologies to help design, display and make furniture. O-LAP is an open-source community run platform for designers to experiment with parametric furniture design. Designers create parametric furniture designs as plugins into the framework. Registered designs gets displayed in the online gallery. Users can view the designs from the gallery and customize the design. Framework lets users extract CAD drawings which can be used to fabricate the design using a CNC machine. The project is built as an open access network of git repositories delivering updated Javascript for the clients.

O-LAP is a community of makers who like to make furniture from code. Designers write code which can create designs for furniture pieces. They make the designs like a plugin into a web app. The app can then extract drawings from the designs which can be used to fabricate the design using a computer controlled machine (similar to 3D printing). Designers can get creative in different ways when they start writing code to create furniture designs. For example they can make the design for a chair which changes for people with different heights, or furniture which learns from your genetic data to customise it for you. We also adapt a new way of production so that such designs can be manufactured by anyone with a CNC machine. It distributes the task of production to independent makers, so the designs are fabricated closest to the place where they are needed, reducing transport. The group has grown with people across the globe interested. It would be great to showcase it to the broader OS developer community.

The organizers of the Legal & Policy Issues DevRoom will reflect on recent developments in software freedom policy and law, and will discuss some of the topics and issues raised in this year's and past year's DevRooms.

If you open the AZip application with a can opener, it will look like an Ada programmer's paradise: you'll find Ada on all levels:

1. the AZip user interface (UI framework specific);
2. the AZip abstract application layer (platform-independent);
3. the archive and data compression library (Zip-Ada);
4. the user interface framework (GWindows);
5. the run-time library (GNAT's).

We will quantify this.

Portability is matched on three different definitions of the word:

1. platform-independence for the abstracted part and the Zip-Ada library - no porting effort at all there;
2. you can easily port the user interface layer since most of the job is done in the abstracted part;
3. no installation needed: the version built on GWindows is contained in a single executable file and can be run from a USB stick; it can be even run in a stealth mode, without writing settings to the registry of the host system.

The web is unimaginably large. Despite all recent challengers, it is still the most successful digital platform in human history. However, the web's centralized nature works against true user agency... and its success is one of the biggest barriers to changing it. Come learn about these challenges and about efforts by Mozilla and other projects to enable decentralized and distributed applications on the web today.

This talk will cover the characteristics and requirements of Scylla's Raft implementation, how it enables strongly consistent updates, and how it improves the reliability and safety of internal processes, such as schema changes, node membership, and range movements.

Eventually consistent databases choose to remain available under failure, allowing for conflicting data to be stored in different replicas (later repaired by background processes). Weakening the consistency guarantees improves not only availability, but also performance, as the number of replicas involved in a given operation can be minimized. There are, however, use-cases that require the opposite trade-off. Indeed, Apache Cassandra and Scylla provide Lightweight Transactions (LWT), which allow single-key linearizable updates. The mechanism underlying LWT is asynchronous consensus in the form of the Raft algorithm. In this talk, we'll describe the characteristics and requirements of Scylla's consensus implementation, and how it enables strongly consistent updates. We will also cover how consensus can be applied to other aspects of the system, such as schema changes, node membership, and range movements, in order to improve their reliability and safety. We will thus show that an eventually consistent database can leverage consensus without compromising either availability or performance.

rust-vmm aims to create a common base of virtual machine monitor (vmm) components written in Rust. It's organized as a shared-effort, shared-ownership open-source project that includes (so far) the crosvm, Kata Containers, and Firecracker teams . We believe that Rust is a great fit for a vmm: its memory management guarantees simplify the task of security hardening, while its roots as a system programming language ensure C-like performance. So far, we've started with the initial KVM wrapper crate, and, while separating out a few more basic functionality crates is underway, we still have to answer questions like "can independent teams compose reliable yet different vmms out of a set of decoupled components?", "how much can be decoupled?", "what's the right way to import/build these components into the larger vmm projects?", or, "does the world even need that many vmms?". During this talk, we'll look at some ways to answer these questions, but we're really here to get the room's feedback and opinions!

In the world of professional QA there are many proprietary test management tools but very few open source ones. This lightning talk will tell the audience why and how we resurrected Kiwi TCMS and what are we doing to make it the best open source test case management system!

FOSDEM marks 10 years since the first version was released and our team will celebrate at the Open Source Test Management stand, Building K, Level 2, stand 10!

Buildroot is an embedded Linux build system that generates complete system images from source for a wide range of boards and processors. I have recently added support for 64-bit RISC-V to the official Buildroot distribution which make it a viable alternative to other build systems for RISC-V such as Yocto.

During this presentation I will give a brief overview of Buildroot and how it compares to Yocto for those in the audience who are unfamiliar with these systems. In the main part of the talk I will look at the issues relating to the implementation of RISC-V support, based on my experiences. This will include a look at the status of the RISC-V software ecosystem with regard to the selection of a suitable toolchain, C library, kernel and bootloader. I will then run through how to configure and build a minimal system for booting under QEMU. Finally I will consider any further work required to improve Buildroot for RISC-V including the status of 32-bit support.

A well known deficiency of Writer is that its Hide Tracked Changes mode is slow. We will discuss the origin of the problem, and the current status of the plans to fix it. Also an aside on leveraging type systems to aid large scale refactoring.

Robust software updates on Embedded Linux devices is complex, and doing robust software updates over-the-air adds to the complexity. The hardships come of course from the embedded environment which differ in many ways compared to desktop or server Linux installations, where you must handle poor mobile network connectivity, sudden power-loss and never leave a device in a unusable state (brick) when doing the update OTA.

There are a lot of examples that have gotten attention in media, where unstable software update solutions have caused real-life problems which could have been mitigated by a robust software solution that is able to handle the corner cases that exist in the embedded environment.

In this talk Mirza Krak will present Mender, Apache 2.0 licensed end-to-end software update solution. This is a deep-dive session that will cover:

Mender project ecosystem Insights to technical solutions/choices Security model/approach Community

Drew will also present some of the features that are being worked on and what lays ahead for the project.

Benefit of Open Source Ecosystem

This presentation will help the open source community get detailed insight of the Mender project and general knowledge of designing an software update system for IoT devices.

During recent work to implement software double precision (fp64) support in Mesa's shading language compiler, some shaders were found to use excessive amounts of memory. One pessimal test case used over 80GiB. This talk will discuss techniques that were used to reduce that memory usage to less the 2GiB. This reduction was achieved through a combination of optimizing existing data structures, use of more compact data structures, and improved memory management. Use of tools such as Valgrind and pahole will be covered.

Salt initially was designed to be an agent-base automation system. Salt SSH was added later on to allow an alternative that does not require installing a agent, and instead communicate over SSH. We will discuss how we modified the initial agent-based solution and the architectural decisions behind this work. We will talk through some of the challenges, lessons learned and what worked well for the project.

How Kubernetes used gRPC to encrypt secrets with an external Key Management Service

In recent headlines, there are increasing news about cloud resources getting hacked caused by attacks on Kubernetes clusters. Failing to properly secure your Kubernetes data can result in cloud resources getting hacked and your application secrets getting stolen. The etcd database contains information that may grant an attacker significant visibility into the state of your cluster.

This presentation focuses on how a gRPC-based implementation was added to Kubernetes to delegate encrypting secrets to an external Key Management Service and the benefits of using a gRPC-based design for this type of problem. Basic knowledge of Kubernetes and gRPC is a plus but not required.