cotalks.dev

FOSDEM

YouTube: @fosdemtalks

| |

Videos (3055)

Deterministic debugging with Delve And the state of Delve

Support for mini-debuginfo in LLDB How to read the .gnu_debugdata section.

Uplift your Linux systems programming skills with systemd and D-Bus Practical examples and best pra…

Our road to a k8s/GKE based Closed Build Environment A small journey to an autoscaling build env ba…

Postmodern strace

GRUB upstream and distros cooperation

Debugging apps running in Kubernetes An overview of the tooling available

Maggy: Asynchronous distributed hyperparameter optimization based on Apache Spark Asynchronous algo…

Low-end platform profiling with HawkTracer profiler

Sharing memories of Python and Rust The story of a lifetime inside Mercurial

cargo deny Fearlessly update your dependencies

Sharing Reproducible Results in a Container A container you can build anywhere

dav1d: 1 year later dav1d is a fast AV1 decoder

Efficient Model Selection for Deep Neural Networks on Massively Parallel Processing Databases

Testing Navit using Device Farms

Homebrew: Features and Funding

VoIP Troubleshooting and Monitoring FAQs

Speed up the monolith building a smart reverse proxy in Go

Software distribution: new points of failure In a censored world

Modern VoIP in Modern Infrastructures Designing and implementing VoIP architectures in the cloud an…

STAC: Search and discovery of geospatial assets Introducing a new cloud-native cataloging specifica…

Monitoring strawberries Building observability for indoor farming

Advancing the Future of CI/CD Together How the Continuous Delivery Foundation is working to advance…

Reinventing Home Directories Let's bring the UNIX concept of Home Directories into the 21st century

Knocking Down the Nest secushareBOX - p2p & encrypted IoT and beyond...

GeoServer Basics

Choosing The Right Deployment Strategy

Arabesque: a geographic flow visualization application

DAT protocol in the browser: Progress and Challenges

openEO: Interoperable geoprocessing in the cloud An open API to connect clients to EO cloud provide…

Building an open source data lake at scale in the cloud

Close lid to encrypt Hard disk encryption in Linux suspend mode

Reverse Geocoding is not easy How doing another mundane geocoding service can provide exciting geos…

Boost.Geometry R-tree - speeding up geographical computation.

WebRTC isn't just for (video) conference calls

GNUnet: A network protocol stack for building secure, distributed, and privacy-preserving applicati…

Async await in Nim A demonstration of the flexibility metaprogramming can bring to a language

Unit Testing with JUnit Jupiter - How to Use the new JUnit Jupiter Platform

From a Pipeline to a Government Cloud How the UK government deploy a Platform-as-a-Service using Co…

rav1e - 0.3.0 and after What we did so far and what will do in the future

Designing an ultra low-overhead multithreading runtime for Nim Exposing fine-grained parallelism fo…

Classify things in Go: the easy way. Building classifiers quickly with the community contributions.

RaptorJIT: a fast, dynamic systems programming language Forking LuaJIT to target heavy-duty server …

Librecast: Privacy and Decentralization with Multicast IPv6 Multicast and the Next Generation Inter…

A small, FRP DSL for distributed systems Mgmt Config: More about our language

Tesselle image viewer Ease viewing and sharing High Resolution images on the web

Nim on everything From microcontrollers to web-sites, C and JS as intermediary languages

Kotlin MP: Into the Multi-Verse

X11 and Wayland: A tale of two implementations Implementing the hikari window manager/compositor

Free Software Radio Devroom Introduction and Hackfest Review

Test Software On Emulated Hardware In Containers... In The Cloud

Bringing back ethics to open source

NetBSD Native APIs - A Userland Perspective (Audio, Input) Discussing and encouraging the adoption …

Forth - The New Synthesis Growing Forth with preForth and seedForth

FreeBSD Around the World!

Getting Your Virtual Hands On RIST

Welcome to the BSD devroom

GStreamer on the Magic Leap One

FreeBSD and LLVM support What is LLVM all about and how it integrates FreeBSD system

How to evolve the GNU Radio scheduler Embracing and breaking legacy

The Space Operations Facility of FH Aachen (FHASOF) The role of freely available and open-source so…

Platform independent CPU/FPGA co-design: the OscImp-Digital framework G. Goavec-Merou, P.-Y. Bourge…

r2cloud - Decode satellite signals on Raspberry PI

The Rise and Fall and Rise of JPEG2000 Currently a niche codec, recent enhancements to the JPEG 200…

Move semantics in Nim Deterministic Memory Management

OpenBeans IDE - Creating an Apache NetBeans Distribution

srsLTE project update

openwifi Opensource "Wi-Fi chip design" and Linux driver

Software Defined Radio based scientific instrumentation using SDR frontends and oscilloscopes for f…

Fibonacci Spirals and 21 Ways to Contribute to Postgres—Beyond Code

IOT Lightning Talks Show us your IOT pet project, 5mins each, don't be shy

Confessions of a Serial K–otlin Multiplatform–er __just don’t 𝚎𝚡𝚙𝚎𝚌𝚝 too much__

Designing a DSL with Kotlin

From Swagger to Kotlin via Gradle Generating your network code has never been so easy

Language Server Protocol & Debug Adapter Protocol to the Rescue of Web Development in Eclipse IDE

Useful coroutine patterns for Android applications

How secure is your build/server? a story of packages and trust

Automate your workflows with Kotlin Forget everything about bash and perl!

Diversity, Finally

Generate a DeepSpeech model with the help of your community How to get fun with teamwork

Continuous Delivery starts with Continuous Infrastructure

Multiplatform Kotlin Library Development

OpenPush Introducing a Free, Decentralized Push Messaging Framework for Android

Discover the New Firefox Profiler

What are the Top 10 Frustrations for Web Developers and Designers? Lessons from the 2019 MDN Develo…

SCION Future internet that you can use today

Facilitating distributed deterministic computation with WASI

Demonstration of the Sculpt Operating System

What Makes People Come and What Makes Them Stay

Rendering QML to make videos in Kdenlive How QML, a language prominently used for designing UI, is …

A Brief Survey through Genode's ARMv8 Playground

VUOS: Give Your Processes a New VU

Building an Open-Source based audio streaming platform

HelenOS in the Year of the Pig

BSP generator for 3000+ ARM microcontrollers

Open Source Hardware for Industrial use OSHW model has benefits for SOC vendors, industrial manufac…

Open Adult Education: a curriculum to bridge the digital skills gap with free and open source techn…

European Software Engineering funded research What has happened under Horizon 2020 and what we alre…

MaadiX, your cloud in your hands Tool Kit and Graphical interface for VPS management

Continuous Integration for Open Hardware Projects

FOSDEM Video Box A bespoke HDMI capture device for conferences.

Tools and mechanisms to debug BPF programs

GDB pipelines -- convenience iteration over inferior data structures Bringing MDB's "walkers" to GDB

Memcheck Reloaded dealing with compiler-generated branches on undefined values

VSCode Extension for OpenShift Developers

Open and federated identities with ID4me An alternative to "sign in with Facebook"

Write Safer JavaScript Applications with TypeScript!

File sharing & storage for human rights organizations A design research case study

Apache DataSketches A Production Quality Sketching Library for the Analysis of Big Data

Extending the lifetime of smartphones with Replicant, a fully free Android distribution

Almonit: Decentralized Websites and Web Services

zbus: yet another D-Bus library The why, how & WTH of creating a pure D-Bus Rust crate

Discover dependency license information with ClearlyDefined License discovery and record-keeping fo…

Explicitly Supporting Stretch Clusters in Ceph

Introduction to the devroom and the Open Source Design collective

Android Content Providers for the Web Using decentralized storage to share data between apps

Dissecting the inline keyword in Kotlin A deep-dive into the internal working of the inline keyword

sled and rio modern database engineering with io_uring

How Kotlin can change developer experience with modern graphics APIs

Idiomatic Kotlin Microservices A live coding session on how to go pure Kotlin with microservices

A Mozilla IoT Forecast thats Sunny and Clear -- No Clouds! WebThings by Mozilla

Working with spatial trajectories in Boost Geometry

JavaScript on Microcontrollers

How Firefox upholds its values and keeps up with change

NOVA Microhypervisor on ARMv8-A

Is the web rea11y for all? Firefox DevTools & A11y

Introduction to G-Expressions Introduction to G-Expressions

XR adds: “Try before you buy”

Make it accessible Tips and tricks for create a good accessible frontend

seL4 Microkernel Status Update

Phantom OS Orthogonal Persistence-based OS Intro and Design Concepts

IoT Projects in FLOSS Foundations A report based on communities data

DuckDB An Embeddable Analytical Database

FOSS in Animation The state of Free and Open Source software in the Animation and VFX Industry

Celebrating Guile 2020 Lessons Learned in the Last Lap to Guile 3

The best of both worlds? Static and dynamic typing in the Crystal programming language

On-hardware debugging of IP cores with free tools

NetBSD - Not Just For Toasters

The year of the virtual Linux desktop

Gofish - a Go library for Redfish and Swordfish

Prioritizing is key How to prioritize thousands of bugs without dying in the attempt

How to run Linux on RISC-V with open hardware and open source FPGA tools

FaaS You Like It: Create Serverless Functions & Run Anywhere

Cooperative Perception in Future Cars using GNU Radio

The elfutils debuginfod server

gr-satellites latests developments

An ultimate guide to upgrading your PostgreSQL installation

Open Source - Killing standards organizations or saving them Open source and standards join forces …

U:Kit: Open-source software and hardware smoke detector

A Deep Dive into PostgreSQL Indexing

Creating Word Clouds with OpenOffice Text mining and visualization in Writer

Find your slow queries, and fix them!

Evolution of path based Geo-replication in Gluster

PipeWire in the Automotive Industry

Integrating Julius Speech Recognition Engine

Beyond the Pile of Knobs: Usability and Design for Privacy, Security, Safety & Consent Privacy and …

Some Excerpts from the Theory of Design in Architecture

Designing to change it all Designing processes and designing some products on the way...

Linux Kernel Library A Library Version of Linux Kernel

FOSDEM infrastructure review

UI/UX Tips & Tricks for developers

Design contributions to OSS: Learnings from the Open Design project at Ushahidi Structuring in-pers…

Accessibility in MuseScore Our experience with Qt and QML

Boosting Python with Rust The case of Mercurial

Build real-world gaming hardware with TinyGo Make toys and other contraptions that run on Go

Threat Modelling for Developers

rustdoc: beyond documentation All the goodies packed in rustdoc, and more

Introducing Tanka From configuration as data to configuration as code

Optimizing rav1e Effective profiling techniques and optimization strategies

LibreOffice lockdown and encryption improvements

Progress of Rust and WASM in 2019 The year in review

Introducing libeconf Bringing systemd-like configuration layering to everything else

Task Scheduling of Software-Defined Radio Kernels in Heterogeneous Chips: Opportunities and Challen…

Open Source design - Africa Open Source Design movement in Africa

Landscape of new challenges in modern virtualization platforms Tackling new issues in virtualizatio…

Heads OEM device ownership/reownership : A tamper evident approach to remote integrity attestation …

An event based approach for CI/CD pipelines What challenges are there in the communication between …

What's up on Haiku? R1/beta2, packaging, porting and contributing.

COLLAB: How can we give users standing in free/open software/hardware?

Overview of Bareos What is Bareos and what is new in 19.2?

Integrating new major components on fast and slow moving distributions How latest GNOME desktop was…

FASTEN: Scaling static analyses to ecosystems

Running virtual machines out of thin air

Distributed HPC Applications with Unprivileged Containers

oVirt-Plugin for Bareos Backing up oVirt using Bareos

Rusty instruments Building Digital Musical Instruments with Rust and friends

The State of (Full) Text Search in PostgreSQL 12

Nouveau Status update The overdue Nouveau status update talk.

A VM journey from VMware to Kubernetes

Reaching "EPYC" Virtualization Performance Case Study: Tuning VMs for Best Performance on AMD EPYC …

GNU Guix as an alternative to the Yocto Project

virtio-fs A shared file system for virtual machines

Open Source Under Attack How we, the OSI and others can defend it

Are You Testing Your Observability? Patterns for Instrumenting Your Services

Online Open Document Editing New Possibilities

Openoffice Build system A walk through building OpenOffice

ERASER: Early-stage Reliability And Security Estimation for RISC-V An open source framework for res…

Lisp everywhere! Gurudom is around the corner

Run ZFS in userspace How we used ZFS in userspace for storage engine cStor

Lightning talk session

Integration Processes Data flowing the easy way

Geo-spatial queries on multi-petabyte weather data archives

Building Homebridge with the Yocto Project

Creating GPX tracks from cycle routes in OpenStreetMap Using the OverpassAPI to download and proces…

coverity and oss-fuzz issue solving common patterns for solving reported issues

Orchestrating jails with nomad and pot A container-based cloud computing platform for FreeBSD

seccomp — Your Next Layer of Defense

Management of Storage on OpenShift Managing storage was never so easy

Asynchronous Directory Operations in CephFS

Rook Cloud Native Storage for Kubernetes Overview and what is new about Rook

Automating Programming and Development of Heterogeneous SoCs with LLVM Tools

Getting inspired by open software for a web site: g3n.fyi

Creating symphonies in JavaScript

Percona Backup for MongoDB: Status and Plans Open Source solution for consistent backups of multi-s…

New features of Vue 3.0

State of Node.js Core

Building Decentralized Social Virtual Reality using WebXR on your browser

PWAs on steroids

The Heptapod project Bringing Mercurial to GitLab

Contributing to LibreOffice without C++ knowledge

MobilityDB Managing mobility data in PostGIS

Open Source Support Program by OTA

NGI Zero: A treasure trove of tech awesome Sampling through the Next Generation Internet initiative

Make Online yours How to customize Collabora Online

GeoNetwork Basics

ROS2: The evolution of Robot Operative System

How to write a scikit-learn compatible estimator/transformer Tips and tricks, testing your estimato…

RedisJSON A document DB in Rust

Divide and map. Now. the damn project

Getting started with FPGA's for Packet Processing Intel FPGA opportunities

Advancing science with Dataverse Publication, discovery, citation, and exploration of research data.

Communication Break Down | Coroutines

When Python meets GraphQL: Managing contributors identities in your open source project

Prototyping the Internet of Things with Wyliodrin STUDIO An open source platform for building IoT p…

Legal Organizer's Panel

Go REUSE to license your code Free Software licensing made simple for everyone

Regaining sovereignty over your router Router freedom

Pattern Based Code Generation for GPUs

emissions API a service to easily access air quality data from remote sensing

CoffeeBeam A BEAM VM for Android

Retro music - Open Cubic Player

Making poetry with Racket Come and see how to make Poems that are also Code!

MySQL Goes to 8!

Quantum classifiers, robust data encodings, and software to implement them

Quantum Advantage and Quantum Computing in the Real World

Quantum computer brands: connecting apples and oranges

The TTM memory manager A general overview and an update on graphics memory management in the kernel

SECCOMP your PostgreSQL

dqlite: High-availability SQLite An embeddable, distributed and fault tolerant SQL engine

A minimal pur object-oriented reflective language A minimal pur object-oriented reflective language

Spring & Steam, an Odyssey

Why the GPL is great for business Debunking the current business licensing discussion

Welcome to the Retrocomputing DevRoom 2020

Why open infrastructure matters

The State of PTXdist

Cappulada: What we've Learned

SimulaQron - a simulator for developing quantum internet software

FOSSH - 2000 to 2020 and beyond! maddog continues to pontificate

The core values of software freedom

The consequences of sync_binlog != 1

WebMIDI The garlic bread of the music industry

Ephemeral Environments For Developers In Kubernetes

libliftoff status update Taking advantage of KMS planes

puavo.org Linux desktops in Finnish schools

Embedded systems, the road to Linux Early boot, comparing and explaining different systems.

Quantum circuit optimisation, verification, and simulation with PyZX

Quantum computing hardware and control systems

State of OpenJDK

The Ethics of Open Source A Critical Reflection

How to integrate secure elements A visually annotated summary of Opensource compatible secure eleme…

In Memory of our Friend, Lars Kurth

Developing from the field Shifting design processes and roles between makers and practitioners arou…

Quantum Open Source Foundation

Universal package & service discovery with Guix Α universal functional package manager and operatin…

PICTOR: A free-to-use open source radio telescope

io_uring in QEMU: high-performance disk I/O for Linux

A tool for Community Supported Agriculture (CSA) management, OpenOlitor

Building a low-cost test fixture

How Yocto extra tools help industrial project Yocto is not (only) bitbake

SpecFuzz: Bringing Spectre-type vulnerabilities to the surface

actinia: geoprocessing in the cloud

Kubernetes on ARM64 Raspberry PI 4 Kubernetes cloud for a few Euros!!

Striving for Performance Portability of Software Radio Software in the Era of Heterogeneous SoCs

Verifpal Cryptographic Protocol Analysis for Students and Engineers

Inspektor Gadget and traceloop Tracing containers syscalls using BPF

Be The Leader You Need in Open Source Learn key skills to guide yourself and your project towards a…

Extending and embedding: containerd project use cases A 2020 containerd project update and descript…

Web compatibility and ML Improving webcompat issue triaging using ML

Linux memory management at scale Building the future of kernel resource management

GNU Mes Scheme-only bootstrap and beyond

The next generation of contributors is not on IRC Discussing communication channels for inclusive o…

Modern asynchronism with coroutines Presentation and best practices of the coroutines framework

How (Not) To Containerise Securely Lessons Learned the Hard Way

Evolution of kube-proxy

Kata Containers on openSUSE

Graphing FreeBSD disk utilization with Prometheus Writing a Prometheus gstat_exporter

HOWTO build a product with OP-TEE

libratbag A way to configure your input devices

Jumpstarting your business with Odoo

A Vulkan driver for the RPI4 A lesson in futility

Back to the Linux Framebuffer! Linux Framebuffer support in free software

strace --seccomp-bpf: a look under the hood

SDR4IoT - Using SDR for IoT Device Fingerprinting and Localization A project part of the FED4FIRE+…

Building a self healing system with SaltStack

Open ESP The Heterogeneous Open-Source Platform for Developing RISC-V Systems

Modernizing Distribution of SDR Tools and Libraries with Conan What does cmake have to do with SNR?

Cacheable Overlay Manager RISC-V

PostgreSQL on K8S at Zalando: Two years in production

Foreman meets Ansible

Building an embedded VoIP network for video intercom systems How to leverage open standards to brin…

RISC-V Boot flow: What's next ?

Immutable deployments: the new classic way for service deployment Adopt the new immutable infrastru…

Mgmt Config: Autonomous Datacentres Real-time, autonomous, automation

Doomed are the dinosaurs! Dealing with diversity by utilizing the versatility of Ansible and open s…

There's no sustainability problem in FOSS Except that there is.

Designing for Failure Fault Injection, Circuit Breakers and Fast Recovery

Relax-and-Recover (ReaR) Mass Deployment

Precise, cross-project code navigation at GitHub scale

Relax-and-Recover (ReaR) Basics with Demo on Real Hardware

What are we talking about when we say "open design"?

License compliance for embedded Linux devices with Buildroot

HPVM: Extending LLVM For Compiling to Heterogeneous Parallel Systems

How lowRISC made its Ibex RISC-V CPU core faster Using open source tools to improve an open source …

Lazy distribution of container images Current implementation status of containerd remote snapshotter

XDP and page_pool API

Quality diagrams with PyCirkuit

Comparing dependency management issues across packaging ecosystems

A community-driven approach towards open innovation for research communication

LXD for mixed system containers and VM workloads Introducing LXD's new virtual machine feature

Percona XtraBackup Current and Future State What’s the future of the open-source industry standard …

Collabora Office Android app gory details How we tweaked LibreOffice & the Online to get an Android…

DataLad Perpetual decentralized management of digital objects for collaborative open science

Revamping OpenRefine a reproducible data wrangler

Monads in Python: why and how?

Challenges and opportunities in scientific software development An example from the neurosciences

Apache Spark on planet scale Using Apache Spark to process OpenStreetMap data

Making & Breaking Matrix's E2E encryption In which we exercise the threat model for Matrix's E2E en…

Thoth - a recommendation engine for Python applications

Why is Django 3.0 a revolution for building websites with Python? From WSGI to ASGI and why it matt…

Channel Equalization using GNU Radio compensating for impairments in the wireless channel, and ext…

Live Demo of Ada's Distribution Features

EUgen: a European Project Proposal Generator

Welcome to the Ada DevRoom

Improving the culture of automated testing in FOSS

Follow Your Celery Tasks

Discover UEFI with U-Boot

Asyncio: understanding async and await in Python

Production-time Profiling for Python

Public clouds and vulnerable CPUs: are we secure?

Introducing HTTPX

Auto-healing cluster through negative testing

FOSS Virtual & Augmented Reality The Monado project & OpenXR

More than one tool for collaborating on writing the Tiki CMS This talk reviews the many collaborati…

How Safe is Asynchronous Master-Master Setup?

oVirt 4k - teaching an old dog new tricks

Automated Performance Testing for Virtualization with MMTests The Tools, the Challenges and also so…

A Rose by Any Other Name Would Run Just as Long Understanding Computational and Hardware Complexity…

Building Blocks for Containerized Ceph How Raw Block PersistentVolumes Changed the Way We Look at S…

RISC-V Hypervisors Where are we ? What next ?

LumoSQL - Experiments with SQLite, LMDB and more SQLite is justly famous, but also has well-known l…

DEBATE: Should FOSS licenses be enforced at all? What means are acceptable if so?

Testing DoH and DoT servers, compliance and performance

Improve your Android app with coroutines Coroutines integration in VLC on Android

Online: wrestling web Copy/Paste to usability Defeating the API and implementation disasters in cop…

Abusing GitLab CI to Test Kernel Patches

KiCad: Back to the Future KiCad and it's role in the growing open hardware movement

Crowdfunding to advance open document editors A status report

What's new in Samba ? Latest news from the Samba project

One test output format to unite them all

Welcome to KernelCI You're all welcome to the KernelCI project's new home

Web3 - the Internet of Freedom, Value, and Trust On exiting the system and reclaiming control of ou…

G1: To infinity and beyond

Ephemeral Pinning: A Dynamic Metadata Management Strategy for CephFS

Incrementality and deck functions Simple protocols and efficient constructions in symmetric cryptog…

Welcome to game development devroom

Writing Go(od) Tests Writing good tests in golang

Userspace networking: beyond the kernel bypass with RDMA! Using the RDMA infrastructure for perform…

Look at ME! Intel ME firmware investigation

Building WebGPU with Rust The new foundation for graphics and compute

Using crio-lxc with Kubernetes

How to fail successfully and reliably And look good while doing it

Blender projects for 2020

Encrypt your collaboration with CryptPad Real demo !

Benchmarking LLVM using Embench

Endless Network Programming − An Update from eBPF Land

Just-in-time compiling Java in 2020

CPU performance analysis for MySQL using Hot/Cold Flame Graph

JRuby Startup and AOT

2nd Generation JavaScript Frameworks & Libraries: Beyond Angular, React, and Vue!

Fedora rawhide packages gating, for real! How we have implemented gating rawhide packages in Fedora

LibreOffice Online adoption into 1&1 Mail&Media ecosystem Brief overview of the open-source adoptio…

COLLAB: The optics of the policy And vice-versa

DEBATE: Does Careful Inventory of Licensing Bill of Materials Have Real Impact on FOSS License Comp…

Releasing Software with GitOps How OpenStack manages releases using Git based automation

Technology challenges for privacy: the case of decentralized social media

Pitch your project

A 'Thin Arbiter' for glusterfs replication

Quantum Game with Photons: Tensors in TypeScript, Visualized

git-issue Git-based decentralized issue management with GitHub/GitLab integration

MySQL 8 vs MariaDB 10.4

Journalists are researchers like any others

Web of Twins From IoT to Immersive worlds and beyond...

Open Source Won, but Software Freedom Hasn't Yet A Guide & Commiseration Session for FOSS activists

Simulating noisy quantum devices with QuTiP

Securing Existing Software using Formally Verified Libraries

The role of open source in building quantum computing ecosystem from scratch Context of a developin…

Do Linux Distributions Still Matter with Containers?

Are PWAs ready to take over the world? Implementing main progressive web app features in practice

Docker Security considerations & Incident Analysis

Building Confidence & Overcoming Insecurity The ultimate software supply chain self-help guide

SCION Future internet that you can use today

BPF as a revolutionary technology for the container landscape

Quantum machine learning with PennyLane

Getting started with quantum software development

istsos3: Data Analysis and statistical tools and unit conversions GSoC 2017, 18 at OSGeo(istSOS)

FOSDEM@20 - A Celebration The cliché of constant change

Yjs: A CRDT framework for shared editing Enable shared editing in every application

Kernel Runtime Security Instrumentation LSM+BPF=KRSI

What you most likely did not know about sudo…

neat-EO.pink: Deep Learning Computer Vision patterns extraction at scale

Introduction to Ansible collections Ansible collections, The future of Ansible content delivery

boot/loader — How to boot Linux and nothing else

20 mins to write a MySQL Shell Plugin Extend the MySQL Shell with a plugin created from scratch

Spack's new Concretizer Dependency solving is more than just SAT!

Code Workload Management into the Control Plane What it means to be "Kubernetes Native"

Towards decentralized alternatives for code collaboration Building Radicle, a peer-to-peer network …

Capsule Update & LVFS: Improving system firmware updates Improving reliability and security by simp…

Building a distributed knowledge base with a Linked Data powered CMS Implementing the vision of the…

Using OpenAPI to Maximise Your Pulp 3 Experience

A Tale of Two Worlds: Assessing the Vulnerability of Enclave Shielding Runtimes

Introduction to Eclipse iceoryx Writing a safe IPC framework for autonomous robots and cars

Improving the Security of Edge Computing Services Update status of the support for AMD and Intel pr…

Flang : The Fortran frontend of LLVM This technical talk introduces the new Fortran fronted of LLVM.

Ask LLVM developers Anything Panel

The Journal of Open Source Software Credit for invisible work

Open source UEFI and TianoCore

LLVM and Python Past, Present, Future

How Transparent Data Encryption is built in MySQL and Percona Server ?

The Confidential Consortium Framework A framework to build secure, highly available, and performant…

OpenSMTPD over the clouds the story of an HA setup

Be secure with Rust & Intel SGX

RISC-V Software and Firmware Development in the Cloud Using OpenPiton+Ariane on Amazon F1

Modernizing mesa3d.org Let's bring mesa3d.org past web 1.0

BlackParrot An Agile Open Source RISC-V Multicore for Accelerator SoCs

Reviving Minitel How web technologies make it easy to emulate Minitel

BASICODE: the 8-bit programming API that crossed the Berlin Wall

repcloud A repacker for PostgreSQL in cloud

Opening Intel Server firmware based on OpenBMC example

Horizon EDA - Version 1.0

Bootstrapping minimal reflective language kernels Bootstrapping minimal reflective language kernels

lognplot - logging and plotting data from micro's Tracing data on a modern laptop

Port luajit to RISC-V Motivation, first steps and perspectives

Zink Update OpenGL on Vulkan upstream in mesa

Alpha Waves, the first 3D platformer ever How 3D graphics worked when there were no graphic cards

On the road to sustainable research software.

Spotlight on Free Software Building Blocks for a Secure Health Data Infrastructure

An Introduction to Ada for Beginning and Experienced Programmers

Stylo : a user friendly text editor for humanities scholars

Double your contributors using these 3 simple tricks! Why would someone work on your project?

Supervising and emulating syscalls

Benefits of porting Godot Engine to Vulkan List of benefits observed from porting Godot Engine to V…

Wallonia GeoChallenge geodata, ideas and challenges

Containers and Steam Putting games under pressure

STEP Reduce Transparent file size reduction for STEP model files

DSpace 7: A major leap forward for the leading institutional repository platform Tale of a mature, …

Shrivelling world A Three dimensional visualisation development for representing geographical time-…

Let me tell you about Raku On why syntax is not so important, with an introduction to the emerging …

Proposal to inspect and highlight styles in Writer

LLVM and GCC Learning to work together

Compliance management with OpenSCAP and Ansible Using OpenSCAP and Ansible for compliance managemen…

Optimizing sandbox creation with a FUSE file system Using sandboxfs to speed up Bazel builds

Integrate Collabora Online with web applications

The good and the bad sides of developing open source tools for neuroscience

Protect Sensitive Data with Ada Keystore

Comparing Hash Join solution, the good, the bad and the worse.

Hacking Terraform for fun and profit

HAC: the Compiler which will Never Become Big

On Rapid Application Development in Ada

Infrastructure testing, it's a real thing!

Designing a performant and scalable graph processing python package

Sparselizard: a general purpose multiphysics FEM library Mechanics, fluids, electricity, magnetics,…

Past, Present and Future of DRLM project

The ultimate guide to HTTP resource prioritization How to make sure your data arrives at the browse…

Oracle v. Google: What are the implications for FOSS?

Cypher enhancements for sharded and federated graph databases

Temporal Graph Analytics with GRADOOP

Break your BSD kernel Fuzzing BSD kernel

Package managers: resolve differences Lively panel discussion on package management

Podman - The Powerful Container Multi-Tool An use case driven hands-on to the container management …

Pocket infrastructures to bridge reproducible research, live coding, civic hacktivism and data femi…

Weblate! Localize your project the developer way: continously, flawlessly, community driven, and op…

Keep Calm and Use Nerves

Pushing the limits of the Web with WebAssembly

Self-hosted server backups for the paranoid Using Borg, SSH, Python and FreeNAS to securely backup …

Kapow! A Web Framework for the Shell

Will somebody *please* tell me what's going on? Managing change in Python projects

Arcade game port to ZX Spectrum A reverse engineering exercise

Preserve kubernetes state using heptio velero

Welcome to the Legal & Policy Issues DevRoom

Running a mainframe on your laptop (for fun and profit)

Closing FOSDEM 2020

Pocket Science Lab from Development to Production

The Ethics Behind Your IoT

Building Loosely-coupled RISC-V Accelerators Using Chisel/FIRRTL to build accelerator templates and…

Akraino Edge KNI blueprint A Kubernetes Native Infrastructure approach to the Edge

Open CASCADE Technology - an introduction and overview

DEBATE: Does FOSS need sustainability?

Improving protections against speculative execution side channel

Skydive A real time network topology and protocols analyzer

Next, the programmable web browser How the architectural choices and the Lisp language make for an …

The hairy issue of e2e encryption in instant messaging

Discover Static Code Analysis in Python with Coala Framework

Improving BIND 9 Code Quality Why is concurrent programming so hard?

Taming Metaspace: a look at the machinery, and a proposal for a better one

Back to the future Incremental backup in oVirt

The pool next to the ocean: How to bring OpenSource skills to more people InnerSource as a way to t…

Weblate: open-source continuous localization platform How to bring your project closer to its users…

Designing Hardware, Journey from Novice to Not Bad Reflections from the OpenElectronicsLab

Correlation analysis in automated testing

Protecting plaintext secrets in configuration files

Frictionless Data for Reproducible Research

Empowering social scientists with web mining tools Why and how to enable researchers to perform com…

Blender, Coming of Age 18 years of Blender open source projects

Guix: Unifying provisioning, deployment, and package management in the age of containers

Transforming scattered analyses into a documented, reproducible and shareable workflow

Using biometric gadgets for express-tests in the UX/UI research

Fast QUIC sockets for cloud networking Using vector packet processing for QUIC acceleration and off…

Alire: Ada Has a Package Manager

Writing Shared Memory Parallel Programs in Ada Multitasked Newton's Method for Power Series

Spunky: a Genode Kernel in Ada/SPARK

Gunrock: High-Performance Graph Analytics for the GPU

Gate project Portable execution state

Secure logging with syslog-ng Forward integrity and confidentiality of system logs

A dozen more things you didn't know Nextcloud could do And a little of what you DID know

Lumen Elixir in the browser

ALTER TABLE improvements in MariaDB Server Optimized or instantaneous schema changes, including ADD…

Gitflow Design A git workflow for design in open-source projects

Welcome to the MySQL, MariaDB & Friends Devroom 2020 Community Welcome

Programming ROS2 Robots with RCLAda

Poio Predictive Text Grassroots Technology for Language Diversity

LibreOffice turns ten and what's next Lots to learn, and get excited about

DEBATE: The 4 Freedoms and OSD are outdated and no longer relevant in 2020

OpenTelemetry: an XKCD 927 Success Story

Processes & Grains A Journey in Orleans

How to create Javascript-powered Smartglasses (no soldering knowledge required)

Falco Internals 101 : Syscalls processing for security analysis What happens when you have: syscall…

Whats new in ProxySQL 2.0? Exploring the latest features in ProxySQL 2.0

Introducing AUTOREV An automatic reverse-engineering framework for firmware BLOBs

Generation gaps

Free at Last! The Tale of Jakarta EE

LLVM meets Code Property Graphs

Farwest Demo A website/API for a document oriented database in 20 minutes

Lexemes in Wikidata structured lexicographical data for everyone

The OpenJDK JVM : Securing a moving target or What could possibly go wrong?

Concept Programming, from ideas to code

Debugging with LLVM A quick introduction to LLDB and LLVM sanitizers

Address Space Isolation in the Linux Kernel

Open lightning talks Showcase your open source project

Edge Clouds with OpenNebula

Reverse engineering a VIC-20 expansion cartridge

MyRocks in the Wild Wild West!

Fritzing - the past, the present and the future Restarting with 1100 technical issues, and a few le…

Hash Join in MySQL 8

OpenPiton: An Open-Source Framework for EDA Tool Development

Running full Linux systems in containers, at scale A look at LXD and its clustering capabilities

Civil society needs Free Software hackers

Rewinding time with System Versioned Tables

SELinux fun with MySQL and friends

HTTP/3 for everyone The next generation HTTP is coming

Extending sudo in Python Best of both worlds

Vita: high-speed traffic encryption on x86_64 with Snabb Coming to your cloud with XDP, AVF, and Ku…

FoxDot and the Summer of 2019

Introduction to Reactive Programming with RxPY

Tracking local storage configuration on linux

LibrePCB Status Update The progress of LibrePCB within the last two years

KDE Itinerary A privacy by design travel assistant

Designing functional objects with functional objects OpenSCAD: Past, present and/or future

Introducing OpenTAP - Open Test Automation Project A developer-first extensible test and measuremen…

Indexing Encrypted Data Using Bloom Filters

Designing and Producing Open Source Hardware with FOSS/OSHW tools We will show you how easy is now …

AXIOM - open source cinema camera Project Introduction and current state of development

OpenQA with the JDP data analyses framework Bug tag propagation on 2M+ test results using Julia

Do you really see what’s happening on your NFV infrastructure? (and what can you do about it?)

Fundamental Technologies We Need to Work on for Cloud-Native Networking

extending catalog zones auto-maintain DNS servers

Using Advene to accompany research in AudioVisual Digital Humanities

Weave Net, an Open Source Container Network Five years with no central point of control

Freedom and AI: Can Free Software include ethical AI systems? Exploring the intersection of Free so…

Container Live Migration

Tracking Performance of a Big Application from Dev to Ops

Running MySQL in Kubernetes in real life

Graffiti A historical, distributed graph engine

Weaviate OSS Smart Graph feature updates, demo and use cases

0 A.D.: Graphics Pipeline How open-source game graphics works

Lightweight virtualization in the Cloud and at the Edge hypervisors gone rogue

The journey of building OpenSpeedMonitor Learnings from unexpectedly finding ourselves developing a…

Java & Games A rivalrous case-study from porting Doom 3

State of djbdnscurve6 IPv6 LLU address support

Mixing kool-aids! Accelerate the internet with AF_XDP & DPDK

NeuroFedora: Enabling Free/Open Neuroscience

unwind(8) A privilege-separated, validating DNS recursive nameserver for every laptop

Raphtory: Streaming analysis of distributed temporal graphs

Shipping a performance API on Chromium Experiences from shipping the Element Timing API

The Neo4j Graph Algorithms Library: An Overview

Finite element modeling with the deal.II software library

Mandos Disk encryption without passwords

ONLYOFFICE: How to securely collaborate on documents within content management applications

How Containers and Kubernetes re-defined the GNU/Linux Operating System A Greybeard's Worst Nightma…

The Hidden Early History of Unix The Forgotten history of early Unix

Nuspell: version 3 of the new spell checker FOSS spell checker implemented in C++17 with aid of Moz…

What's in my food ? Open Food Facts, the Wikipedia of Food Mixing mobile crowdsourcing, ai, opensou…

The history of error correction and detection and how it led to Ceph’s Erasure Coding Techniques

SWIM - Protocol to Build a Cluster SWIM gossip protocol, its implementation, and improvements

Hacking on GraalVM: A (very) Rough Guide

Confronting Clang and Fedora

DNS Management in OpenStack What is the OpenStack DNS API?

The Different Ways of Minimizing ANY

The Linux Kernel: We have to finish this thing one day ;) Solving big problems in small steps for m…

DeskConnD: Secure, cross-platform IPC on the network Zeroconf + WAMP = Cross platform IPC

Automating schema migration flow with GitHub Actions, skeema & gh-ost And end-to-end schema migrati…

EActors: an actor-based programming framework for Intel SGX

Python for Godot

Rethinking kubernetes networking with SRv6 and Contiv-VPP

Over Twenty Years Of Automation

Programmable Unified Memory Architecture (PUMA)

Regaining control of your smartphone with postmarketOS and Maemo Leste Status of Linux on the smart…

Wikibase Ecosystem taking Wikidata further

Knocking down the barriers of ORDER BY LIMIT queries with MariaDB 10.5

WPE, The WebKit port for Embedded platforms

Debugging and tracing a production RabbitMQ node

Hardware-Software Co-Design for Efficient Graph Application Computations on Emerging Architectures

MySQL 8.0: Secure your MySQL Replication Deployment

Below Kubernetes: Demystifying container runtimes

The unsupervised free CAT for low resource languages Building a pipeline for the communities

Open-source design ecosystems around FreeCAD

Analyzing DPDK applications with eBPF Sharpening the toolset

Ada-TOML: a TOML Parser for Ada

ByteBuffers are dead, long live ByteBuffers!

Metrics and models for Web performance evaluation or, How to measure SpeedIndex from raw encrypted …

Replacing iptables with eBPF in Kubernetes with Cilium

DEBATE: Should licenses be designed to advance general social goals?

Project Loom: Advanced concurrency for fun and profit

The Selfish Contributor Explained

Reducing OpenJDK Java Garbage Collection times with stack allocation

Overview of encryption features

LibreOffice Theme Changer An Extension for Customize LibreOffice Appearance in Easy Way

Hint, Hint, Font Loading Matters! Fonts are lovely but can slow down our loads. How can we make the…

Leveraging Open Source Designs Creating a component search engine for reference designs used in pra…

HashDNS and FQDNDHCP IPv6 DNS configuration made easy

Reloading Escoria Make point and click adventure games under Godot great again

Bringing Collabora Online to your web app Its easy to add rich document collaboration to your web a…

Fixing the Kubernetes clusterfuck Understanding security from the kernel up

Application Whitelisting in Linux Environment

ngspice open source circuit simulator dev update and electrothermal simulation

Dial your Networking Code up to 11 Vectorizing your network app to break the performance barrier

Protect your data objects, not your network connections Good news for a paradigm shift

Custom Crypto Policies by Examples Management of crypto algorithm restrictions

Oreboot RISC-V Firmware in Rust

Welcome to FOSDEM 2020

Going Meta with Elixir's Macros Running at compile-time and compiling at runtime

JMC & JFR - 2020 Vision

Using SELinux with container runtimes

The HammerBlade RISC-V Manycore A programmable, scalable RISC-V fabric

Game development with OpenXR

From 0 to Intranet in 20 minutes with XWiki

Check Yourself Before You Wreck Yourself Auditing and Improving the Performance of Boomerang

Testing a large testing software

Daala Video Codec

TornadoVM: A Virtual Machine for Exploiting High-Performance Heterogeneous Execution of Java Prog…

Helpful NullPointerExceptions - The little thing that became a JEP

STS in Ceph Object Storage

Speed without Shenanigans How Rust and WebAssembly is changing the web as we know it

Best Tech Talks Recommended by InfoQ Editors

Troubleshooting Kubernetes

The final release of Kodi v18 A two year development story

LibreHosters A federation of networks for cooperation and solidarity through distributed platforms.

Enough: How journalism can benefit from free software

Making your Python code write your Python code Discover Python's 'ast' module to see how you can an…

The consequences of sync_binlog != 1

When open source meets quantum computing Opening keynote

Deep Dive: Kubernetes Metrics with Prometheus

A new approach to container isolation with Nabla

Breaking Down Language Barriers Localizing for access, activism and preservation

Solid: taking back the Web through decentralization App development as we know it will radically ch…

Call C++ from Rust with the cpp crate Interoperate with C++ libraries, using Qt as an example

Introduction to reSIProcate A quickstart for C++ SIP application development

GraphHopper Routing Engine - New Features Overview of the latest features and development

A year of Container Kernel Work Past, Present, and Future of Container Kernel Features

Evolution of file system and disk management in HelenOS

Node.js feature-flipping through Git Git as a Continuous Manager

Taming The Dinosaur: How Eclipse was Performance Tuned

Open Source Geolocation The story and challenges ahead

Stories from BIND9 refactoring Dealing with code that can drink legally

D-Wave's Software Development Kit

Migrating from Adobe Connect - the Victory of FOSS Over Proprietary Software

The impact of Meltre and Specdown on microkernel systems (*) (*) Deliberate misspelling of Meltdown…

OpenStreetMaps for emergency prep: The view from San Francisco Using OpenStreetMap and QGIS to buil…

2019 - Fifty years of Unix and Linux advances

Embracing Language Servers for Blockchain Development

VoIP Troubleshooting and Monitoring with SIP3 Twenty Thousand MPS under the SIP: VoIP network troub…

Rewriting Pointer Dereferences in bcc with Clang Syntactic sugar for BPF programs

Where is my error gone?

Continuous Localization How we ship localized versions of Firefox, on Laptops and Android

GNU Mes Reduced Binary Seed bootstrap for GNU Guix

Microkernel lightning talks

Organisational Processes in Decentralized Software roundtable open to decentralized software develo…

Continuous Integration to compile and test Navit

Real-time container automation and scheduling Mgmt Config: Containers

Will you boot Haiku, on a non intel platform, no BIOS winter? Booting Haiku on non-x86, a never-end…

Creating a Computing Revolution: from Personal Computers to Personal Servers

Resurrecting Mozilla Themes for LibreOffice Trying to uncover, fix and improve a hidden gem in the …

Package software for any distribution with upt

An Introduction to Ada for Beginning and Experienced Programmers

Blockchain: The Ethical Considerations

TypeScript-It's time to migrate!

Testing your infrastructure and services with the help of OPNFV testperf team

Extend Emacs in C or Other Languages

Lesson learned from Retro-uC and search for ideal HDL for open source silicon

Revoking the 2010 DNSKEY Monitoring the events of 11th of January 2019

Testing Over 1000 gTLDs for EDNS0

Predicting areas for PR Comments based on Code Vectors & Mailing List Data

Documenting Validator Requirements

Around the world with Postgres extensions

Hacking PostgreSQL

Mattermost’s Approach to Layered Extensibility in Open Source

Introducing Kubeflow (w. Special Guests Tensorflow and Apache Spark)

Open source software security testing Crowd supported via bug bounty

ZFS Powered Magic Upgrades Using boot environments for atomic in-place upgrades

Time is Important - Developer Centric IoT Platforms

Latest evolution of Linux IO stack, explained for database people

Component-based Design System and Development

Challenges With Building End-to-End Encrypted Applications - Learnings From Etesync

XDP (eXpress Data Path) as a building block for other FOSS projects

The brief case for User-space Network Stacks (DPDK and friends) The case for DPDK, FD.io VPP, Snabb…

Make your own language with Racket A kickstart workshop for the creative minds

A Guiler's Year of Racket

The Yoast Design Meeting and how it started us on the path to open source design

PennyLane - Automatic differentiation and machine learning of quantum computations

MySQL 8.0 Document Store: How to Mix NoSQL & SQL in MySQL 8.0 a database where developers and DBAs …

Raspberry Pi history, tips and use case its history, how to use it and what is its good use case

Roll your own compiler with LLVM Easy IR generation

Packaging for Mageia Linux with Docker containers

Clang plugins in LibreOffice - global analyses across a large codebase

Why JSON when you can DSL? Your problematics deserve their own language

What's new in PostgreSQL 11

Breaking PostgreSQL at Scale

CI/CD for embedded development with an ESP8266, Arduino-cli, Gitlab-ci, Raspberry Pi, and Kubernete…

Kubernetes Network Security Demystified

Mobile design with device-to-device networks Exploring the design space of novel technologies throu…

Distributed Computing with Ada and CORBA using PolyORB

Securing Secure Boot on Xen

Building production-grade networking software with FD.io CSIT Building fast and robust networking s…

Tools for Shrinking Your Containers

The future of Supervisor Binary Interface(SBI)

The real cost of not doing user research And how to get insight-based decisions on a budget

llvm.mix Multi-stage compiler-assisted specializer generator built on LLVM

Extending Numba

Extending syslog-ng in Python Best of both worlds

A follow-up on LTTng container awareness System level tracing in a containerized world

Spatial Reference Systems Transformations with Boost.Geometry

Dynamic answer generation with Lua An exploration of the LUA record from the upcoming PowerDNS rele…

Porting U-Boot to a Modular Device Booting Linux via U-Boot on a board which can be composed of sev…

Redfish: the new standard for a Software Defined Infrastructure

Zink OpenGL on Vulkan

A Deepdive into Tantivy

Pocket Science Lab - An Open Source Hardware for Electronics Teaching & Learning

VR Map: Putting OpenStreetMap Data Into a WebVR World Simple GeoData Visualization with A-Frame

Rated Ranking Evaluator: an open-source approach for Search Quality Evaluation How to automate the …

Set-versioned package dependencies addressing the problem of shared library updates

How should lawyers behave? Legal "Ethics" and Free Software

LLVM for the Apollo Guidance Computer

A microkernel written in Rust: Porting the UNIX-like Redox OS to Armv8 A case study of Rust as a la…

Making Sense of so many License Compliance Tools

Tapping Into the Binary Log Change Stream

How Kubernetes used gRPC to encrypt secrets with an external Key Management Service

Medical image reconstruction using the .NET Framework

openEMS - An Introduction and Overview Using an EM field solver to design antennas and PCBs

Advocating For FOSS Inside Companies Redux

Astor: An automated software repair framework

Super-speedy scoring in Lucene 8

Bring JavaScript to the Internet of Things - From Embedded Device to Smart Gateway

Leveraging ceph-mgr modules for fun and profit

Making the next blockbuster game with FOSS tools Using Free Software tools to achieve high quality …

Design Automation in Wonderland The EPFL Logic Synthesis Libraries

Coming: a Tool for Mining Change Pattern Instances from Git Commits

A low latency GPU engine based reset mechanism for a more robust UI experience

Securing the JVM, neither for fun nor for profit, but do you really have a choice?

FST-01SZ (Flying Stone Tiny 01 revision ShenZhen) free hardware design for Gnuk Token

Reinventing MVC pattern for web programming with F#

Organizer's Panel -- Now and Forever

The Software Developer’s Guide to Open Source Hardware

Open source virtual prototyping for faster hardware and software co-design Make your hardware / sof…

NFS-Ganesha Weather Report

Onion adventures how to use onion services and the Tor network in your web endeavors

eBPF powered Distributed Kubernetes performance analysis

Exporting Ceph Object Storage data to the outside world RGW Sync Modules for fun & profit!

Open Source C#, .NET, and Blazor - everywhere PLUS WebAssembly

The right to data portability (and why it's a very bad idea) How the RGPD leads to the DTP and why …

Retroshare JSON API Making libRetroshare a generic service for decentralized and private communicat…

Nextcloud decentralize the way we sync, share and collaborate

Love What You Do, Everyday!

Fine-grained Distributed Application Monitoring Using LTTng

Introducing DBus-ASIO How and why we built a new D-Bus library from the ground up

Hyperledger Fabric - Blockchain for the Enterprise

BinAST Let's make the javascript startup bottleneck a thing of the past!

Introducing the CERN Open Hardware Licence version 2 Covering some of the major changes in this new…

When and How to use CGo Or, Foreign Functions for Fun and Profit

Using Progressive Web Apps to control IoT Using a PWA app to control an IoT device using JS framewo…

JavaScript: If you love it, set it free

Designing Command-Line Tools People Love

Automating Client Library Generation How and Why

ossia ecosystem workshop Combining media of all kinds with libossia and ossia score

A year of LXD development Project update on what happened in LXC/LXD in 2018

Now what? Following through on your community guidelines

Who wants you to think nobody uses the AGPL and why

Good Will Snapping ~10 benefits of publishing your application in the Snap Store

LibreOffice: the origins of a community fork

Debian Java: Insights and challenges learn more about the daily work to package Java software for D…

How Online Backup works in MyRocks and RocksDB

LibreOffice Online - hosting your documents Keeping your documents close and yet collaborative

Profiling PHP applications

MariaDB and MySQL — what statistics optimizer needs or when and how not to use indexes

Promotion of open source and role of standardization in Quantum Computing Open panel discussion

The surprising interaction of open source and patent exhaustion

Hands on debugging with Delve

Building a Hardware MIDI Player Exploration of Linux's System Interfaces

New interoperability, i18n and LibreLogo improvements of LibreOffice for office suite migrations in…

Memex: Collaborative Web-Research & the next generation knowledge management tools.

Quo vadis, LibreOffice extensions?

A small, FRP DSL for distributed systems Mgmt Config: The Language

Online - under the hood How to bring LibreOffice to your web app

Converse: Open, federated teamchat with XMPP

Redis Labs & the tragedy of the Commons Clause

Making Open Source Hardware for Retrogaming on Raspberry Pi

Updates from the RISC-V TEE Group Working on a Trusted Execution Environment spec for RISC-V

TLS 1.3: what developers should know about the APIs

Computer Games with MicroPython Become a full-stack game developer.

MySQL Performance Schema in 20 Minutes

Hacking F# in JS ecosystem

Next Generation Internet initiative - Year Zero Come work for the internet on privacy, trust, searc…

Introduction to the BASIC Engine A low-cost single-board home computer programmable in BASIC that c…

Make your code count: Quantum simulations and collaborative code development Introduction to QuTiP:…

Are we optimiert yet?

The First Contact

Metaprogramming with Nim

Preventing OOXML interoperability problems in LibreOffice

Never Functional Programming Language

Do you know "layers"?

Native GTK Dialogs current status and future work

Using SAIL to generate GNU assembler/disassembler and simulator for RISC-V

Nuspell: the new spell checker FOSS spell checker implemented in C++14 with aid of Mozilla

FreeRTOS on RISC-V Running the FreeRTOS kernel in RISC-V emulators and RISC-V hardware

Tuning a Runtime for Both Productivity and Performance

Vereign toolbar in LibreOffice Online Technical aspects of integration of a 3rd party document sign…

Autonomous Train Control Systems: a First Approach

Yet Moar CSS Features

Pitch your project Designers meet projects. Projects meet designers.

Luerl: Lua in Erlang Luerl introduction emphasizing its trade-off as scripting skin on top of the B…

0 A.D: Graphics Graphics problems and opportunities of open-source game

HDMI CEC: A Status Update

Designing for Activism An overview of the UX overhaul of OONI Probe

Infrastructure as Typescript

Toward exploring virtual disks using a file manager!

VkRunner: a Vulkan shader test tool A presentation of VkRunner which is a tool to help test the com…

LLVM+Clang for RISC-V Past, present, and future

Typescript =❯ IL =❯ Game Modding Supercharged

.NET and TypeScript Lightning Talks

Valkyrja and the tale of eating servers using C# Valkyrja project - why .NET Core, C# & Fedora Linu…

Kamailio VoIP development update

Environment Modules Provides dynamic modification of a user's environment

Advanced TypeScript tooling at scale

Strawberry Fields - software for photonic quantum computing

Intel® Hardware Intrinsics in .NET Core

What is Safety-Critical Software, and How Can Ada and SPARK Help?

.NET Core 2.1 in Production How Namely develops .NET Core services

YunoHost An essential building block for the decentralized Internet

Buildroot for RISC-V Using Buildroot to create embedded Linux systems for 64-bit RISC-V

Retro.NET - .NET for building Console Applications

Alternative languages for safe and secure RISC-V programming

How to build an automatic refactoring and migration toolkit

KernelCI: a new dawn How the KernelCI project is getting a second breath

Informal Discussions & Closing

Making furniture with Javascript An open-source community run platform for designers to experiment …

Squeezing Water from Stone - KornShell in 2019

Open Source Hardware for Smart City OSHW LoRaWAN implementation for Parking, Air quality, City ligh…

Do you think is easy to create a console app?

Rumble in the Java Jungle

DNSSEC security without maintenance ... with the right software and registry

Northbound Connections of VPP for NFV in Containers and Kubernetes

Fedora on RISC-V 64-bit Introduction, Brief Overview and Latest Developments

GRUB upstream and distros cooperation

Shrink your Data to (almost) Nothing with Trained Compression

Open Educational Resources on Digital Accessibility for Building Your Own Courses

Is a single DNS vendor enough? Discussion about complexities of multi-vendor deployment, and why yo…

Build your own GC with OpenJDK in 20 minutes

Parallel programming in Go for performance with the Pargo library

Making furniture with Javascript An open-source community run platform for designers to experiment …

Beyond the 10%: analysis of the gender-diversity gap

Dark Peak Data Co-op Sheffield Geeks Freeing Their Data

How libre can you go? Reaching as many viewers as possible using only libre video technologies.

Cilium - overview and recent updates

What is Rust doing behind the curtains? Exploring syntactic sugar with cargo-inspect

Writing X11/Wayland agnostic GL applications with Waffle

Writing a CNI - as easy as pie Write you own CNI (Container Network Interface)

Digital Predistortion Implementation and Use

XMPP Beyond Instant Messaging How we use XMPP to do many neat features

Latest developments in Boost Geometry

How compact is compiled RISC-V code?

OpenTrailView 360 FOSS StreetView for hikers

VPP & Ligato use cases: Contiv/VPP CNI plugin for Kubernetes & IPSEC VPN gateway Development of clo…

Fraud mitigation using traffic pattern monitoring with CGRateS

From the idea to the prototype using FLOSS

A Scalable Approach to Virtual Switching

Ceph wire protocol revisited - Messenger V2

From table to index (and back) with Hibernate Search 6 Leveraging Elasticsearch's power with a rela…

From closed to Open Source switch ASICs The transition in the world of switching asics

Java Language Futures

Emitter: Scalable, fast and secure pub/sub in Go

Are you insured against your noisy neighbor?

Automation networking engine for enterprise SDN Ansible Networking and OpenDaylight integration

ONOS Introduction Overview of ONOS, Open Network Operating System from ONF, the Open Networking Fou…

It was working yesterday! Investigating regressions with llvmlab bisect A hands-on introduction to …

State of OpenJDK

Perl 11 The Future of Saint Larry's Language

Building a whole distro on top of a minimalistic language The story of GNU Guix

FOSS Governance: The good, the bad and the ugly

Clustered Samba: Witness Protection Programming

Real-time virtualization automation Mgmt Config: Virtualization

Java 4..12, Kotlin, Code Coverage and their best friend — bytecode: scandals, intrigues, investigat…

Open source in the quest for GDPR compliance

Deploying PostgreSQL on Kubernetes

Mgmt Config: A tale of three graphs Real-time, autonomous, automation with graphs (mostly DAG's)

XCP-ng: building an Open Source and turnkey virtualization platform From Kickstarter to the datacen…

Eventyay! An event system for community organizers

DNS as code with octodns Versioning and keep track of your dns records changes and automatize all t…

Improve OSM data quality with DeepLearning

Bare Metal In The Cloud: Isn’t it Ironic? Explaining OpenStack bare metal provisioning service

RIST - an evolutionary video transport protocol

U-Boot from Scratch v2019.01 edition

How to write a reverse-proxy with Go in 25 minutes

Distribution build / delivery styles, one style to rule them all ? Is rolling release the answer fo…

Suggesting Fixes during Code Review with ML

Rootless Kubernetes Running Kubernetes and CRI/OCI Runtimes as an unprivileged user

Using getdns for local DNSSEC validation

Differentiated access control to graph data Applied to TinkerPop-compatible graph databases

Leveraging real-time streaming with Neo4j-Streams

How to create a useful MySQL bug report ...and make sure it's properly processed

Welcome to FOSDEM 2019

Approaching Light Speed - News from the Eclipse Platform Project

HOMER RTC Stats Timeseries for Fun and Profit

A walkthrough guide to implementing a compiler intrinsic

EBUs - Live IP Software Toolkit Open Source Software in professional media

Apply complex network configuration to your Kubernetes cluster hosts by declaring it

Mysql connector and other databases in LibreOffice Changes around database drivers in LibreOffice

Hands-on composition of basic L4Re components

It's Time for the Populator Declarative initialization of kubernetes persistent storage

High performance virtual machines in oVirt Explain oVirt solution for easy creation of virtual mach…

Replicated SDS with DRBD & LINSTOR An Open Source SDS for the automated management of storage clust…

Getting To Blinky: Virt Edition Making device pass-through work on embedded ARM

Introduction of OSS Weaviate, the Decentralised Knowledge Graph What is a decentralised knowledge g…

Going mobile with React Native and WebRTC How Jitsi Meet went from web to mobile, while sharing mos…

Deep Learning on Massively Parallel Processing Databases

Lessons learned from porting HelenOS to RISC-V Pros and cons of RISC-V from a microkernel OS point …

Video Analysis using CUDA and OpenCV Detecting scene changes in videos using CUDA and OpenCV

An introduction to Middleware Application Monitoring with Java Mission Control and Flight Recorder

Java with Docker: How to Make it Work

Solving Polynomial Systems in Python phcpy: a scripting interface for PHCpack

The Missing Benchmark Metric: Memory Consumption

Russian crypto algorithms in the OpenSource world GOST crypto demystified

TiDB: Distributed, horizontally scalable, MySQL compatible

Scale Your Auditing Events

Java Checkpoint/Restore

Hardware/Software Co-Design for Efficient Microkernel Execution

Making the JIT part of the cloud

Graph usage in EFL using graphs to navigate a UI

What are your users kubectl-ing into your Kubernetes cluster?

Performance tuning Twitter services with Graal and Machine Learning

Debug info in optimized code - how far can we go? Improving LLVM debug info with function entry val…

On Observability Observability 101

OpenJDK Governing Board Q&A

Fractalide and Cantor A Racket application built with Flow-Based Programming

Reducing Memory Usage of Mesa's Shader Compiler (Again) Why does this shader need 80GiB to compile?

the current and future state of Ethereum layer 1 scaling, layer 2 scaling, proof of stake and Sere…

Improve your SQL Common Table Expressions (CTE) and Window Functions

Challenges in Monitoring Distributed Storage Environment and how Tendrl addresses them

V4L2: A Status Update

Secure Web Applications with AWA

Hugepages and databases working with abundant memory in modern servers

GNU Radio in 2019: Facts and Plans An overview of where GNU Radio is going this fine year

Monitoring Kubernetes and Virtualization

Fearless Multimedia Programming using GStreamer & Rust

The Container Storage Interface, Explained

Go containers? Go serverless? A cloud native journey

Tested for Business: An Open and Transparent Quality Kit

High end augmented reality using Javascript Using markers with a webcam is cool but what about a Ho…

Patterns and anti-patterns in OSS participation Lessons from MySQL AB, the MariaDB Foundation, and …

Panel: Difficulties in having more designers participate in Open Source

Test complex database systems in a laptop with dbdeployer The friendly tool that makes DBA and deve…

Storing "Lots Of Small Files" in a Swift cluster

Crostini: A Linux Desktop on ChromeOS

Improving LibreOffice quality together A summary of what happened in 2018

Project Things A secure gateway to connect your things to Internet

MySQL Replication - Advanced Features

The art of multiplexing MySQL connections with ProxySQL

LATERAL derived table in MySQL

How we use Gluster offering Gluster-as-a-service

D-Wave Hybrid Framework

Porting Debian to the RISC-V architecture Tales from a long quest

Pocket Science Lab Developing FOSS Hardware and Scaling up to Large Scale Production

Enrich your NIC's capabilities with DPDK SoftNIC

What makes LLD so fast?

Unikraft: Unikernels Made Easy

Lightning Talks

gRPC, Protobufs and Go... OH MY! An introduction to building client/server systems with gRPC

How to build a FreeBSD CI/CD environment based on pot container

PWA caching strategies How to obtain maximum performance from your Progressive web app

A brief story about friendship What we learned from cross-community collaboration

Do Linux Distributions Still Matter With Containers? Yes, because stopped statically compiling thin…

Cogito Privacy starts with Identity

Maemo Leste A Debian/Devuan based mobile hacker OS

Linux and USB Audio Class 3

GStreamer 1.16 and beyond

Structured Concurrency Finding our way out of callback hell

Portable Services are Ready to Use Portable Services bring some container features to classic servi…

The New Internet let's talk about IPFS

Protect your bits: Introduction to gr-fec A look into the error-correction capabilities of GNU Radio

The Skulls project - coreboot your Laptop The easy way

UEFI Boot for Mere Mortals

Multiplex graph analysis with GraphBLAS

Consistent PKCS#11 in Operating Systems improving user experience and security in RHEL and Fedora

The Dwingeloo radio telescope goes SDR

Autocrypt - Automating E-Mail Encryption What E-Mail can learn from the success of end-to-end encry…

HTTP/3 HTTP over QUIC is the next generation

An End-to-End LTE Testbed in Three Clicks

MySQL 8.0 Component Infrastructure Why, what's there, what's next and how to use it

What's new in DeepSea An overview of new features

Rspamd integration into FreeBSD.org mail infrastructure

Linux distributions, lifecycles, and containers

Asterisk 16: What's new in the world of Asterisk

Experience with wisp 5 years with fewer parens

My 10 year journey with FOSSASIA: A woman's pathway to open source

GNU Radio meets Scapy

SDR Makerspace sdrmaker.space

Unifying network filtering rules for the Linux kernel with eBPF

Go Lightning Talks Come speak!

Neural commit message suggester Proposing git commit messages with neural networks

Solo5: A sandboxed, re-targetable execution environment for unikernels A {unikernel,kernel} is just…

Introducing rust-prometheus How Rust makes metrics safe and fast

Write Drunk - Test Automated Different aspects of Continuous Integration Testing for documentation …

Sans IO: safe and testable network protocols Building safe, deterministic and testable network prot…

Data Modeling, Normalization and Denormalization

Building a Multi-Node SIP Platform Using OpenSIPS Cluster multiple OpenSIPS nodes to create a highl…

Hikar - Augmented reality for hikers Developing an app and framework for outdoor AR

Who needs pandoc when you have Sphinx? An exploration of the parsers and builders of the Sphinx doc…

VR Map: WebXR with Real-World OSM Data Simple GeoData Visualization with A-Frame

Decentralizing the Web Despite Itself

Performing Low-cost Electromagnetic Side-channel Attacks using RTL-SDR and Neural Networks

Developing data structures for JavaScript Why and how to implement efficient data structures to use…

Profiling Low-End Platforms using HawkTracer Profiler

Flickerfree boot Seamless boot for UEFI systems

To the future with Grav CMS How we migrated from a Wiki to the open-source Grav CMS

OpenEBS asymmetric block layer in user-space breaking the million IOPS barrier

Tracking users with core Internet protocols Enhancing privacy and performance the Internet

Merging System and Network Monitoring with BPF Merging packets with system events using eBPF

Getting to Closer to a Software Help Language Untangling complexities of the LibreOffice Help

Why, and How, we compiled Xaml into IL

SMB2 POSIX Extensions Where we are, what remains to be done.

Global Consent Manager Improving User Privacy and the Consent Experience for Trusted Websites

10 years of open source test case management with Kiwi TCMS

Code anomalies in Kotlin programs Automatic detection of anomalous code fragments written in Kotlin

Countless, Beautiful Contributions

Inclusion Includes You Let's talk about how inclusion benefits all of us

How XR goes beyond demos and games Is XR just a trend? Or is there more to it?

Building Pantheon documentation Feedback about on our documentation team experience

VBoard, making web dashboards in 3D and VR

Validating Big Data Jobs An exploration with Spark & Airflow (+ friends)

Flamethrower A flexible tool for DNS load and functional testing

Open Source Firmware at Facebook "If you don't own your firmware, your firmware owns you"

Building modern desktop apps in Go

How and why (not) to use the 127.0.0.53 nameserver, systemd-resolved and resolvctl Or what is syste…

The State of Webassembly in 2019 DevTools, support and specifications ready and in progress in 2019

The Current and Future Tor Project Updates from the Tor Project

How to write pylint plugins

Managing and Monitoring Ceph with the Ceph Manager Dashboard Introduction / Overview and Demo

Firecracker, should it work only with a single runtime?

Linking OpenStreetMap and Wikidata A semi-automated, user-assisted editing tool

GObject subclassing in Rust for extending GTK+ & GStreamer Or: How to safely implement subclassing …

GNU Radio with a Rusty FPGA Experiment building FPGA accelerated blocks with Rust bindings

Minimalism matters

Inject the Web into your GStreamer pipeline with WPE using a GStreamer/WebKit source element

ActivityPub panel

Couple scientific simulation codes with preCICE A journey towards sustainable research software

CK: an open-source framework to automate, reproduce, crowdsource and reuse experiments at HPC confe…

Nakadi: Streaming Events for 100s of Teams Serving all sorts of users and use cases, the sane way

Building Immersive Experiences with the Web The power of the Web with WebXR

A roadmap for the Hurd?

Building an LLVM-based tool Lessons Learned

Microkernel virtualization under one roof Dare the impossible

Asterisk WebRTC frontier: make client SIP Phone with sipML5 and Janus Gateway Analyzing a real proj…

Beyond the webrtc.org monoculture Alternative WebRTC implementations in C and Python

An overview of Tezos focusing on On-Chain Governance A new develoment paradigm for the blockchain

Embedded with Go: from an AWK prototype to a gokrazy appliance How to build a self-contained toy fo…

Introduction to OpenAPI Specification

Tiki: Easy setup of wiki-based knowledge management system This talk demonstrates how to build up a…

Hey, A Blockchain-Based Social Network Leveraging Ethereum Sidechains Towards Scalability

CubicWeb Linked Data Browser Extension

Tuning Go GC Parameters

Who needs to know? Private-by-design collaboration

Document Redaction with LibreOffice Preventing Leakage of Sensitive Information by Redaction in Col…

A private cloud for everyone Why and how Nextcloud builds a private cloud software

GBForth: Using Forth to understand the Game Boy

Welcome to the Legal and Policy Issues devroom

Working with Webhooks

Collabora Office on iOS

Async PHP Requests & Reactive Responses with PHP-FPM

XR The present, the future and how to get there.

Greenfield: An in-browser Wayland compositor Running a Wayland compositor entirely in your browser

Complex cameras are (were?) complex How to make complex cameras easier: an update from the Libcamer…

Templating Languages for Interactive Fiction

Intel GFX CI: Validation done the Linux way

Migrating a Big Data Cluster from Linux to FreeBSD Slowly, but steadily

Guile 3: Faster programs via just-in-time compilation

Automated firewall testing

An Update on NetBSD and pkgsrc

An update on Virtio What happened recently and what's coming soon?

Walking through walls PostgreSQL ♥ FreeBSD

.NET on the Web with Mono WebAssembly

FreeBSD Graphics

Dotting the ethics i and crossing the t Solid ethics for FOSS user research

Panel: Open Source .NET

Using networks to study 18th century French trade

Welcome to the Ada DevRoom

Open Source Design in the trenches: a case study How we redesigned the FOSDEM video review interface

How a Connect-X device driver works How we wrote a Connect-X 4/5 10G-100G driver for Snabb

UX at Tor an Open Approach

Managing VMs and Containers in a Deeply Integrated UI

Make Room! Make Room! Space saving techniques in oVirt

IMAP, JMAP and the future of open email standards a look at what's new in the IMAP world and the up…

Open Software deserves Open Hardware How Europe is taking the lead in Open Hardware

bmclib: A Baseboard Management Controller library One library to rule them all?

Square Kilometre Array and its Software Defined Supercomputer ... and a very fast parallel file sys…

Matrix in the French State What happens when a government adopts open source & open standards for a…

Controlling the Execution of Parallel Algorithms in Ada

The SReview review system

What did I just agree to? A quick trip through the un-"popular" open source licenses

Preserving numerical algorithms

Gephi JS: Exploring the dystopian future of a Javascript Gephi

Un-split brain (aka Move Back in Time) MySQL

Persistence with Ada Database Objects

LAVA federated testing Testing with and by the community

Monica, a personal CRM Remember everything about your friends and family

GStreamer embedded state of the union 2019

Tree matchings with Behavior Trees How to recognize a complex subtree in a big tree

Compiling the Linux kernel with LLVM tools

ElasticSearch Correctness and perfOrmance Validator Formally measuring the cost of a query before h…

The convergence of HPC and BigData What does it mean for HPC sysadmins?

A quick update on singularity 3.0 singularity 3.0

KiCad Project Status Everything you wanted to know about the state of the KiCad project.

Upcoming Kubernetes Storage features transfers, clones and populators

Connecting .NET Core to D-Bus

Memory Management in Python A Short Overview of CPythons Memory Management

One image to rule them all Single boot image for SBCs

Fritzing - the past, the present and the future Paving the way for Fritzing's development

Drawing PCBs with Inkscape Creating printed circuit board designs using Inkscape, SVG2Shenzhen and …

Setting up an HPC lab from scratch with Mr-Provisioner, Jenkins and Ansible

Salut à Toi: A Python Based Social Network And More A multi-platforms communication ecosystem based…

SMT-Based Refutation of Spurious Bug Reports in the Clang Static Analyzer

The state of machine learning operations in 2019: reproducibility, explainability, bias evaluation …

Towards a sustainable solution to open source sustainability

MySQL and the CAP theorem: relevance & misconceptions Dissecting, affirming and refuting CAP assump…

How We Modified an Agent-based Automation System to Become an Agentless One Lessons and Architecture

The Kitspace BOM Builder Create bills of materials and buy parts with the information you need at y…

Forest: An Open Source Quantum Software Development Kit

Voice Controlled Radio Enabling broadcast reception for Smart Speakers

Minimalism versus Types An experience report on the development of Titan, a statically-typed Lua-li…

Introducing kubectl-trace bpftrace meets Kubernetes with kubectl-trace

Tcl - An Embeddable Long-lever with a Comfortable Grip, that fits in your Pocket.

Git database with bitmap index

Use kcli with all your virtualization solutions!

FreeBSD in Audio Studio FreeBSD is usually not the first choice for music art, but it has quite a l…

RAPIDS Data Science on GPUs

Distributed ledgers finally brought me a usable digital identity!

libsigmf: Human Tools for Extra-Terrestrial and AI Radios

Running Android on the Raspberry Pi Android Pie meets Raspberry Pi

Rust and GNOME Adoption and impact of Rust through out GNOME

FreeIPA and cross-distribution packaging experience

Server side solution for generating ODF reports An important step to adopt ODF in Taiwan

Better loop mounts with NBD Take your loop mounts to the next level with nbdkit

Understanding Source Code with Deep Learning

Displaying other Application data into a Wiki … and other integrations

An operator centric way to update application containers with AtomFS

Add enterprise 2FA to your ownCloud in 15 minutes

Fighting spam for fun and profit the long road to SpamAssassin 4.0

Loom: Weaving executions

GWL: GNU Workflow Language

Embedded FreeBSD on a five-core RISC-V processor using LLVM How hard can it be?

Mastering Application/Service Configuration How to cover your configuration needs with oslo.config

Streaming Pipelines for Neural Machine Translation

IGT GPU Tools - the past, the present, the future

Ten years of Puppet installations: what now? Lessons learned, sane suggestions, outlook for the fut…

Analysis of the behavior of mobile applications and its consequences for our privacy Presentation a…

Make XMPP Sprint Again

Multilingual Kubernetes The kubernetes.io stack, how we got there, and what it took to get there

Speeding up Programs with OpenACC in GCC ... using the compute power of GPUs and other accelerators

Project Trellis and nextpnr FOSS FPGA flow for the Lattice ECP5

Etherlime: open source blockchain development tool An open source tool for Ethereum developers

Open Source at DuckDuckGo Raising the Standard of Trust Online

Keeping Track of Stateful Infrastructure An overview over InnoGames infrastructure and the tools we…

KLEAK Practical Kernel Memory Disclosure Detection

AI image search with Go & Tensorflow Integrate the advances of AI in your Go apps

Augmented Network Visibility with High-Resolution Metrics

"Collaboration in Open Source Is the Better Way"

Writing Network Drivers in High-Level Languages How to write drivers in Rust, go, C#, Swift, Haskel…

Quantum Computing at Google and in the Cloud An update on Google's quantum computing program and it…

GraalVM: Polyglot Development Platform with Great Toolability

Console oriented services: wttr.in, cheat.sh, rate.sx

Codifying infrastructure with Terraform for the future

Community Data is Not Community Metrics One Team's Journey Down the Wrong Path

Smelling Source Code Using Deep Learning

DNS and the Internet's architecture: the DoH dilemma Impacts of DNS-over-HTTPS on how the Internet …

Pulp 3: Ready for a Test Drive

Multicloud CI/CD with OpenStack and Kubernetes

Mgmt Config: The Road to 0.1 Real-time, autonomous, automation

A containerd project update 20 minute project update for 2019 FOSDEM containers devroom

Deduplication on large amounts of code Fuzzy deduplication of PGA using source{d} stack

Latency SLOs done right

VNF development made easy with netmap A flexible framework for high performance packet processing w…

MALT, A Malloc Tracker

rust-vmm shared virtualization crates

Uyuni: A world-class open source frontend solution for managing your software-defined infrastructur…

Neuropil - Secure Interaction for Things Elevating Security for IoT with the First Decentralized Op…

Automate Kubernetes Workloads with Ansible Easy deployment, self-service provisioning, and day-2 ma…

Web Components are the future. And the future is now!

Feature store: A Data Management Layer for Machine Learning Data Management for ML

The DAO of Bisq

Mender - an open source OTA software update manager for IoT

Demystifying Coroutines and Asynchronous Programming in Python

Loki - Prometheus for logs

Using eBPF for Linux Performance Analyses

Configurations: Do you prove yours ?

Use configmanagement for your ... configmanagement.

ID4me: using the DNS as a directory for identities Who needs a blockchain when you have the DNS?

Designing for Security

Declare your Linux Network state!

Privacy-preserving monitoring of an anonymity network Data Collection, Analysis, and Visualisation …

Microcontroller Firmware from Scratch

Gluster Container Storage Storage for containers, in containers

Companies and Communities Why Can't We All Just Get Along?

Containing the RDMA plasma An experience report on wrapping a wildly unsafe library

Ceph storage with Rook Running Ceph on Kubernetes

XWiki: a collaborative apps development platform Build applications incrementally on top of XWiki r…

Critical Path Analysis

Futatabi: Multi-camera instant replay with slow motion

Text Markup to PDF with Python

Compute the QOS of your infrastructure with DEPC

The Open Source Community: its past and future What I learned about the Open Source Community while…

RecordFlux: Facilitating the Verification of Communication Protocols

Open Food Network open source for worldwide food systems

OpenScore Open-sourcing sheet music

Sysadmins, too, deserve interface stability Designing a stable interface to abstract OS configurati…

Introduction to dpdk-burst-replay A tiny tool for easily inject pcap files on DPDK NICs

What's new in the world of seL4

horizon EDA - what's new

Back From the Dead Resurrecting a national FOSS organization

Wayland in IVI systems In-Vehicle-Infotainment systems and their graphics sub-system

Unified Communications with Pàdé Making the X in XMPP work with software

Theo: The Authorized Keys Manager How to manage easily and securely ssh accesses to your servers

Virtual IOMMU Implementation using HW Nested Paging

Cloud Native Security 101

Substrate An Open-Source Framework for Building Blockchains

DNS Privacy panel A discussion about all aspects of DNS Privacy

Consorting with Industry Sustainability, FLOSS and building a local small business consortium

ELI5: ZFS Caching Explain Like I'm 5: How the ZFS Adaptive Replacement Cache works

Mining Source Code^3 Mining Idioms, Usages and Edits

Hackers gotta eat Building a Company Around an Open Source Project

Learning to Rank Explained for Dinosaurs

M3 and a new age of metrics and monitoring in an increasingly complex world

Lucene Upgrade in Jira 8.0 How we fought and killed the code debt beast

Sustaining FOSS Projects By Democratizing The Sponsorship Process How we run and manage our FOSS Su…

Condition Monitoring & Transfer Learning Good predictions in situations with (initially) almost no …

Cappulada: Smooth Ada Bindings for C++

Cross browser extensions

Beyond The First Steps Key ideas and advices to improve your development posture

Supporting FOSS Community Members with Impostor Syndrome Mentoring and supporting peers with impost…

Data services in a hybrid cloud world with Ceph Making data as portable as your stateless microserv…

Improving SmartArt import in LibreOffice Impress

Let's use centralized log collection to make incident response teams happy

Netflix and FreeBSD Using Open Source to Deliver Streaming Video

Handling Security Flaws in an Open Source Project - Jeremy Allison

No evidence of communication and implementing a protocol: Off-the-Record protocol version 4 Version…

Interactive Computing with F# Jupyter

Perl 6 as a new tool for language compilers Using Perl 6 grammars to design and implement a program…

The Cloud is Just Another Sun

Building open source scientific equipment How researchers are owning their own instruments

Tesla Hacking to FreedomEV! Bringing Freedom to electric vehicle software

openSUSE Kubic for Container People Exploring the Containerised Frontiers

PostgreSQL Goes to 11!

Learning about Deep Learning: Applications for OpenJDK/Java Verification

RustPython: a Python implementation in Rust Building a Python 3 interpreter in Rust

PostgreSQL vs. fsync How is it possible that PostgreSQL used fsync incorrectly for 20 years, and wh…

Proof of Pointer Programs with Ownership in SPARK

Break the Messaging Silos with COI Get to know the Chat Over IMAP initiative

Automated Analysis of TLS 1.3

Breaking the 100 bits per second barrier with Matrix An entirely new transport for Matrix for reall…

gr-soapy: A handy SDR hardware interface module for GNU Radio

Firefox is your Marionette Get fun using the unit test system to control Firefox

The TPM2 software community Getting started as a user, becoming a contributor

Can Anyone Live in Full Software Freedom Today? Confessions of Activists Who Try But Fail to Avoid …

Hacking NodeJS applications for fun and profit Testing NodeJS Security

Discover GraphQL with Python, Graphene and Odoo

Sustain in Open Source with Gitcoin Gitcoin is a decentralized application where you can use variou…

Operating System hardening : Dealing with external interrupts

FOSDEM infrastructure review

Leela Chess Zero Learning chess from scratch

Speeding up the Booting Time of a Toro Appliance

JavaScript for open computing education

LemonLDAP::NG 2.0

gtk-rs: newest and future developments Progress report on GTK+ Rust bindings

P4: Private Periodic Payments Protocol

Raft in Scylla Consensus in an eventually consistent database

When perf-html Met A11y

MicroPython – Python for Microcontrollers How high-level scripting languages make your hardware pro…

Apache Lucene and Apache Solr 8 What’s coming next?

Exponential speedup in progress Closing remarks

Reproducible science with containers on HPC through Singularity Singularity containers

Less painful E2E tests with Cypress.io

FLOSS, the Internet and the Future

What's new in Ceph Nautilus project status update and preview of the coming release

MALT & NUMAPROF, Memory Profiling for HPC Applications

0 A.D., a libre real-time strategy game "History is yours for the taking!"

USB borne attacks and usable defense mechanisms Hardening built into the operating system without c…

Real-time merging of config management and monitoring Mgmt Config: Monitoring

Decoding Meteor-M2: QPSK, Viterbi, Reed Solomon and JPEG from IQ coefficients to images, analysis o…

Base64 is not encryption A better story for Kubernetes Secrets

Watching Them Watching Us WebExtensions Exposing Privacy Leaks

Testing GraphQL in your JavaScript application

SUSI.AI: An Open Source Platform for Conversational Web

Building a Community Metrics Strategy

SAYMON - object-oriented monitoring and management for both ICT&IoT object hierarchies and time-se…

slapdcheck Monitoring OpenLDAP with Python

The new EU CyberSecurity Act Or how to prevent the EU from becoming the worlds largest botnet hone…

How to build your own Ethereum client The development story of Nimbus

ReFrame: A Regression Testing and Continuous Integration Framework for HPC systems

From jQuery to React Gradual migration with hybrid approach

Hundred thousand rides a day How can a massive amount of GPX traces help us improve OpenStreetMap

Writing Asynchronous SNMP Agents From a MIB file to a fully-fledged Python application

openSUSE Kubic for Distro People exploring the containerised frontiers

PipeWire PipeWire wants to take over your multimedia

Protecting Secrets with Hardware Secure elements, hardware wallets, and device support for cryptocu…

RustPräzi: a tool to build an entire call graph of crates.io From package-based to precise call-bas…

HWallet: The simplest Bitcoin hardware wallet

Spoofing GPS is it really the time we think it is, and are we really where we think we are ?

From Oracle to Apache - News from Apache NetBeans

From Zero to Portability Apache Beam's Journey to Cross-Language Data Processing

3Geonames.org An open source Geocoding system for the simple communication of locations with a reso…

Lessons in TableGen

OpenGreffe Decentralised company register for decentralised companies

Improve your project’s on-ramps for new participants

Coaching for Open Source Communities 2.0

25 Years of FreeBSD

Closing FOSDEM 2019

"Enlightening" KVM Hyper-V emulation

Tooling for IntelliJ Platform Plugins

Ethics in the workplace

Change your perception about complex developments

Test your code in Python

Optimizing Python code

What is FOSS and why is it important?

Python and Raspberry Pi Physical computing, GPIO, HATs and IoT with Python

Python Data Structures implementation list, dict: how does CPython actually implement them?

Storing metrics at scale with Gnocchi The Python based time series database

How to run a stable benchmark

Cloud Native Python The road to being a first-class Kubernetes application

Asynchronous programming with Coroutines in Python A gentle introduction

Optimization with PuLP

Python and "the SOLID principles"

Debugging Hung Python Processes with GDB

Introduction to Pandas Introduction to the open source data analysis and manipulation library

Hacking midi devices with StepPy a step sequencer in Python

Selinon Distributed dynamic task flow management with Python

prompt_toolkit two years later

asynctest easier testing of asyncio code

Script the Web with Weboob Yes we can use the Web outside of Browsers

(Ab)using Google's Chromium-EC firmware for your own designs Building Franken-Chromebook-devices

Analyzing the Software Development Life-Cycle using Data-Mining Techniques

Software updates with OSTree Why and how

AGL as a generic secured industrial embedded Linux Factory production line controllers requirement…

Making Your Own Open Source Raspberry Pi HAT A Story About Open Source Harware and Open Source Sof…

Isar Build Debian-Based Products with BitBake

How to fix Usually Slightly Broken (USB) devices and drivers? Sniffing traffic on your USB bus

Secure and Safe Updates for Your Embedded Device

Groking the Linux SPI Subsystem

GrimoireLab a Python toolset for software development analytics

Creating the open connected car with GENIVI

How to Build an Open Source Embedded Video Player

Visualize Your Code Repos and More with Gource

Open source is just about the source, isn't it?

Closing loops Concluding discussions in non-face-to-face communities

Sharing power in our communities Designing and implementing better spaces for everyone

Data Science for Community management

Building an Accessible Community

Overcoming Culture Clash

I contributed ! But what now ? This talk will be about methods to improve contributor retention rat…

Binary analysis with angr Using VEX for static analysis

Like the ants turn individuals into large contributing community

Successful and not (yet?) successful optimisations in Valgrind

VEX Where next for Valgrind's dynamic instrumentation infrastructure?

sparcv9 New architecture to be supported by Valgrind

Mentoring 101 How to be a great community mentor

fortification vs memcheck Making gcc/glibc fortification and valgrind memcheck work better together

A dozen years of Memcheck Looking backwards and looking forwards

Valgrind, the anti-Alzheimer pill for your memory problems

Alerting with Time Series

Social aspects of change

Trace Everything When APM meets SysAdmins

Valgrind BoF and Hackaton Open discussion of ideas for Valgrind - and then we hack!

Graphite@Scale or How to store millions metrics per second

What does "Monitoring" mean?

Grafana - Past, present and future

Impromptu Q&A about Prometheus and Grafana

Monitoring Kubernetes with OMD Labs Edition and Prometheus

Deploying Prometheus at Wikimedia Foundation

Pet-VMs and Containers united?

modular VDEplug: switchless switching networks (and libslirp) VDEplug now supports plugins... inclu…

QEMU: internal APIs and conflicting world views How abstractions inside QEMU (don't) work together

VM: Hey VM, can I share a host with you? Affinity rules in a virtual cluster

Adventures in Building Unikernel Clouds or a Crash Course in Building L2-L7 from Scratch

20 years of Linux Virtual Memory From simple server workloads to cloud virtualization

Live patching the Xen Project hypervisor

Using NVDIMM under KVM Applications of persistent memory in virtualization

OpenStack with Machine Containers Replacing VM's with Fast and Secure Machine Containers

Towards a HVM-like Dom0 for Xen reducing the OS burden while taking advantage of new hardware featu…

Network Block Device how, what, why

Improving your virtualization development workflow with Lago

The next generation Certainty in shared storage environments

Singularity The Inner Workings of Securely Running User Containers on HPC Systems

Managing container infrastructure

Kubernetes Operators Managing Complex Software with Software

CRI: How Kubernetes really runs containers

OpenStack Magnum at CERN Scaling container clusters to thousands of nodes

Cloud Native Java Development Patterns and Principles for Designing Kubernetes Applications

gRPC 101 - building fast and efficient microservices

Running virtual machines in containers

cgroupv2: Linux's new unified control group hierarchy

Managing DEPENDENCIES in containers

Is it safe? How compliance and scanning fit with Config Management

Kubernetes+GlusterFS Lightning Ver.

Config Management Community Awesome, Awful or Apathetic?

Puppet Catalog Diffs in TheForeman Using octocatalog-diff to view catalog changes in the Foreman UI

Replacing Dockerfiles with Ansible-container

Does your configuration code smell?

opsi: client management for heterogenous environments An introduction to opsi.

Quit managing the infrastructure to manage your infratsructure OpsTheater, an open source stack of …

SELinux Support over GlusterFS

Evaluating NVMe drives for accelerating HBase NVM HBase acceleration

Deploying Ceph Clusters with Salt

Hyper-converged, persistent storage for containers with GlusterFS

GlusterD-2.0 The next generation of GlusterFS management

Ceph and Storage management with openATTIC

Storage overloaded to smoke? Legolize with LizardFS!

FastDataStacks A fast and flexible platform for high performance applications using FD.io

Ceph weather report

Introduction to Ceph cloud object storage

Ceph USB Storage Gateway

Ceph and Gluster Community Update

Getting Started with OpenDaylight

Open-Source BGP networking with OpenDaylight using OpenDaylight to enable advanced BGP use-cases

The emergence of open-source 4G/5G ecosystems

switchdev: the Linux switching framework running a mainline kernel on network gear

Writing a functional DPDK application from scratch

Cilium - BPF & XDP for containers

Accelerating TCP with TLDK overview of the architecture and implementation of TLDK

Stateful packet processing with eBPF an implementation of OpenState interface

When configuration management meet SDN

PNDA.io Big data platform

What do you mean ’SDN’ on traditional routers?

Opening network access in the Central Office Open Source initiatives addressing new models for a fu…

eBPF and XDP walkthrough and recent updates

Infrastructure Monitoring with Postgres

Tour de Data Types VARCHAR2 or CHAR(255)?

An overview of PostgreSQL's backup, archiving and replication

Evolution of Fault Tolerance in PostgreSQL

Beyond Trust - PostgreSQL Client Authentication

Bringing the Semantic Web closer to reality: PostgreSQL as RDF Graph Database

sysbench 1.0: teaching an old dog new tricks

Painless MySQL HA, Scalability and Flexibility With Ansible, MHA and ProxySQL

MySQL & Friends Devroom Welcome

MyRocks The RocksDB storage engine for MySQL

Inexpensive Datamasking for MySQL with ProxySQL data anonymization for developers

Introducing gh-ost GitHub's triggerless, painless schema migrations for MySQL

Honeypot your database And easy method to detect if you've been hacked

Optimizing MySQL without SQL or touching my.cnf

Speeding Up Analytical Queries in MariaDB CTE's and Window Functions Highlight

Mix ‘n’ Match Async and Group Replication for Advanced Replication Setups

Autopsy of an automation disaster

Fine tuning Group Replication for performance

Data Analytics with MySQL, Apache Spark and Apache Drill

Group Replication A Journey to the Group Communication Core

Applying profilers to MySQL From PMP to perf, and why performance_schema is not a replacement in al…

Instrumenting plugins for Performance Schema

MyRocks in production at Facebook

The Proxy Wars - MySQL Router, ProxySQL, MariaDB MaxScale

Desktop security, keeping the key to the castle safe

Panopticon A Libre Cross-Platform Disassembler

Get the most out of your security logs using syslog-ng

How to audit, fix (and be merry) with OpenSCAP & Foreman Security & Compliance automation with Fore…

WTF my container just spawned a shell

Simulation of MITM in PEAP with hostap application of EAP state machines from hostap for MITM simul…

Is the Linux Desktop less secure than Windows 10? What Gstreamer, Chrome, Tracker and Baloo mean fo…

Footprinting for security auditors

Tanker Embrace the relational model

AF_KTLS - TLS/DTLS Linux kernel module

TLS Test Framework How to check if your SSL server is standards compliant and client compatible

The PTags Linux Security Module

Smart card forwarding

Usable Cryptography with José C and command-line JSON Object Signing and Encryption

Unbreakable unit tests

Webpush notifications for Kinto

MSS - Software for planning research aircraft missions

OSINT Tools for Security Auditing Open Source Intelligence with python tools

The power of duck typing and linear algrebra How linear algebra and python make a good fit

PHP in the graph

Python Winding Itself Around Datacubes How to Access Massive Multi-Dimensional Arrays in a Pythonic…

It's time for datetime Painless working with time in python

rinohtype The Python document processor

Boost up your code with Specifications

Gomobile Android development with Go

Metrics and an application log Your new best friends

Go lighting talks Lighting talks about Go

From text logs to extensive automatic monitoring

go-git A pure Go implementation of Git

gobpf - utilizing eBPF from Go

High performance and scaling techniques in Golang using Go Assembly

The state of Go What to expect in Go 1.8

High-performance IoT Using Go and Gobot

Implementing 'tail -f'

Creating a dashboard with Laravel, Vue and Pusher

Transform your monolith into a nice SOA app

Shenandoah Why Do We Need Yet Another Garbage Collector

Eclipse 4.7 Platform - The new greatness

JDK 9 Outreach - The Awesome Parts

Diagnosing Issues in Java Apps using Thermostat and Byteman.

Experiences in a production environment (Graal)

Open J9 - The Next Free Java VM

The State of OpenJDK

Optimizing Errors Away

Challenges updating your code to work with Java 9 Jigsaw

Three ideas for the G1 GC (and how to get involved)

Reflections on Adjusting Trust: The Mozilla Root Program Tales of running an open and transparent C…

Ruby's Strings and What Java Can Learn From Them

Helping Linux and Java Play Well Together

OpenJDK Governing Board Q&A

Panel of European legal entities for Free Software projects

Why we need a legal framework to operate a Trusted Service Provider successfully An overview of som…

How We Talk About Free Software Legal Tools

F as in Freedom Codes of Conduct & Community Guidelines

FOSS and the GDPR Overview of key changes to EU privacy law that FOSS can use to promote individual…

Protect your freedom to operate with Open Patents Hacking the patent system.

Patently Prepared Are FOSS Companies Ready to Deal with Patents in the US and Europe?

Is the GPL a copyright license or a contract under U.S. law?

Don't Send An Engineer To Do A Lawyer's Job A beginners guide to community legal engagement

Radio Lockdown Directive Major threat for Free Software on radio devices

Bits, Gates, Traces, and Pins Copyleft and Licensing in Open Hardware

What legal and policy issues concerning FOSS need to be systematically researched?

A discussion of Fedora's Legal state This is why I drink.

Making License Compliance Easy: Step by Open Source Step.

Free/open source software and drones Safety, security and privacy issues

Mixed License FOSS Projects Unintended Consequences, Worked Examples, Best Practices

Principled free software license enforcement An open source company perspective

Make your Corporate CLA easy to use, please!

An open Gravimetric Phenotyping system Finding low-cost solutions to continuous plant monitoring fo…

Copyleft in Commerce. How GPLv3 keeps Samba relevant in the marketplace

Prove with SPARK: No Math, Just Code How to prove key properties of Tetris and run it on ARM Cortex…

Yet Another repoman How We Do CI at oVirt

Supercharge your collaboration with an Open Source Wiki and stop using closed source solutions like…

Citybikes Bike sharing networks around the world

Kopano Introduction to Kopano Collaboration Platform

libuv Cross platform asynchronous i/o

Energy data what, how, and why

SOFA - Real-time multi-physics simulation with an emphasis on medical simulation

Analyze terabytes of OS code with one query How to leverage the code shared on GitHub with ease

GRUB New maintainers, news and future

Outlook CalDav Synchronizer The missing link in FOSS Exchange server replacement

Mailing List, Meet CI Combining Patchwork and Jenkins for fun and profit

tslib release party state of the touchscreen access library

GridSound : A free HTML5 Digital Audio Workstation (DAW) Pushing the boundaries of the Web Audio API

Interledger - Internetworking for Money Payments & Micropayments to/from Any Currency

OSIS - Open Student Information System A Belgian university decides to open source their core busin…

FOSDEM infrastructure review

64 bit Bare Metal Programming on RPI-3 Your first aarch64 bare metal program

Programming Reconfigurable Devices via FPGA Regions & Device Tree Overlays A User View Benchmark on…

Scaling your logging infrastructure using syslog-ng

OpenScore - by MuseScore and IMSLP Open-sourcing music with open source software

TPM2.0 practical usage Using a firmware TPM 2.0 on an embedded device

LizardFS - distributed file system made easy A fault tolerant, distributed, parallel and easy to us…

Let's talk about hardware: The POWER of open. How Open POWER is changing the game and why the Free …

Connecting End Users and Developers With the Requirements Bazaar

How to write your novel with open source application Introduction to bibisco

QtPass and opensource project management The road from a 2 day project till inclusion in all distro…

Network Policy Controller in Weave Net Blocking unwanted network traffic in Kubernetes

Encryption for the masses with pretty Easy privacy (p≡p) A rough overview

Learning programming in the XXI century How to say goodbye to "Hello, world"

The Armadito antivirus project modular, multi-platform & a management console

Crazyflie and Loco Positioning System News from the Crazyflie universe

Virtuozzo containers, how it works virtuozzo, most known as openvz containers techonlogy

Tempesta FW Linux Application Delivery Controller

Passbolt Open source password manager for teams

Alyvix: Under the hood Visual synthetic monitoring of network applications that work through propri…

The s6 supervision suite A modern alternative to systemd

From pipelines to graphs Escape the tyranny of the shell’s linear pipelines with dgsh

From TRL to MRL: Assessing Open Source Project Market Readiness

User Session Recording for the Enterprise An Open-Source Effort by Red Hat

What open source and J.K. Rowling have in common Importance of storytelling in open source projects

Free Software For The Machine

Bridging the Gap between Legacy Docs and Modular Content

RISC-V Open Hardware for Your Open Source Software

Bazel How to build at Google scale?

Pieter Hintjens In Memoriam For ZeroMQ and all the rest

Continuous Localisation using FOSS tools Building a fast responsive localisation process using open…

Libreboot Free your BIOS today!

LoRaWAN for exploring the Internet of Things Talk Hard: A technical, political, and cultural look …

The Veripeditus AR Game Framework Enabling everyone to freely create Augmented Reality Games

Datacubes on Steroids with ISO Array SQL Open Source, Open Standards, Open Terabytes

From zero to first test in your own LAVA laboratory (in less than 30 minutes)

Open Source Car Control

Continuous Integration at a Distribution Level Shepherding 30.000 packages to never break

Kernel DLC Metrics, Statistic Analysis and Bug-Patterns

Success and Failure in Building an Open-Source Software Platform for Autonomous Driving Systems

Loco Positioning: An OpenSource Local Positioning System for robotics Presentation with a demo of a…

How I survived to a SoC with a terrible Linux BSP Working with jurassic vendor kernels, missing pie…

Learning IoT & coding with HTML5 games Introducing Clouduboy and Happy Code Friends

Adding IEEE 802.15.4 and 6LoWPAN to an Embedded Linux Device

Testing with volcanoes - Fuego+LAVA Embedded testing going distributed

Device Tailored Compositors with the QtWayland Compositor Framework

What motivates the open source community? - a qualitative exploration of the underlying experiences…

How Rust is being developed The Rust development dashboard

Embedding/Maintaining SpiderMonkey in a large scale project

Introduction to A-Frame Build Virtual Reality on the Web

Don't break the Internet!, Mozilla Copyright Campaign in Europe

Firefox DevTools Deep Dive

Corrode Tool-aided translation from C to Rust

Firefox: The Puppet Show Automating Firefox with WebDriver using Selenium and GeckoDriver

Discourse development for beginners

Diversity User Research and Women in Open Source Becoming a Better Listener and Women in Open Sourc…

Rebooting Firefox Nightly A community building project around the Firefox Nightly Channel

(Mobile) Web Compatibility Why is important to care about users from different platform. How can yo…

Web Logins after Persona How I solved logins on my small websites

WebRender, the next generation graphics engine by Mozilla research A technical talk about the web r…

So that was HTTP/2, what's next?

Firefox and WebExtensions

An introduction to functional package management with GNU Guix

User interfaces with Guile and their application

Workflow management with GNU Guix

Lua API for RTC Services with Kamailio Build scalable VoIP services with Lua

Network freedom, live at the REPL!

Adding GNU/Hurd support to GNU Guix and GuixSD Porting Guix and GuixSD to GNU/Hurd

Reproducible packaging and distribution of software with GNU Guix Distributing software with Guix

Composing system services in GuixSD or how we came to wonder what a "system service" really is

Small languages panel

Natural script writing with Guile The newest step on my path towards the perfect script writing syn…

Mes -- Maxwell's Equations of Software An attempt at dissolving [GuixSD's] bootstrap binaries

Hacking with Guile… Or how I stopped worrying and learned to love the REPL

How I Learned to Stop Worrying and Love Tumbleweed Why everyone should be running a rolling release

Mageia, successes and lessons learned 6 years after forking Retrospective and future plans from the…

Distributions from the view of a package

RDO's continuous packaging platform How to continuously package OpenStack (or other things) for Cen…

Transactional Updates with btrfs

Modularity & Generational Core The future of Fedora?

Writing Open Source Documentation for Open Source Projects How SUSE is documented and what we can l…

Source code Are we not forgetting something?

Continuous Integration with the Open Build Service

Deploying NPM packages with the Nix package manager

Using a generic distro to redefine IoT

Building a distro with musl libc Why and how Alpine Linux did it

Bundling KDE Where does KDE land in the Snap and Flatpak world?

Free Software In Europe's Public Sector HOWTO open source in public administration

From Gtk to Qt: An Strange Journey, part 2 The continuation of the original talk from Dirk Hohndel …

Classic Applications in a Confined Ecosystem Using libertine to run deb-packaged, X11 applications …

Electron Solving our cross-platform dreams?

Kube The next generation communication and collaboration client

Haiku, a desktop you can still learn from No, you didn't steal all our ideas yet ;-)

KDE SlimBook Q&A

Open source behind a web request explaining a web request through open source software

Corporate WebDesk Building the next corporate applications

Retro desktops for retro computers From 8-bit to Atari, Amiga & friends

Interoperability regression testing in LibreOffice

Cleaning up the spellcheck dictionary And making it faster and more maintainable

The Office Pokémon GO IV Calculator Games, Fun, and Hacks with OpenOffice/LibreOffice

Office Basic Source Code Management OpenOffice/LibreOffice Basic Development with 3rd-Party Editors…

LibreOffice and your IDE gbuild, json and other buzzwords

Tackling the LibreOffice update problem Automated updates and update statistics

The Document Foundation Development Dashboard: hands on

LibreOffice XML Help in your local browser Bringing 2017 to LibreOffice Help

Lightning talk session Open Document Editors DevRoom 5 minutes each - come to submit until 30 minut…

Exploiting Concurrency How I stopped worrying and started threading ...

Announcements and Lightning talks

Enhance metafile importers - a restart First steps in re-architecting our various metafile / svg im…

Integrating LibreOffice Online via WOPI

The Document Foundation Development Dashboard How LibreOffice is being developed

LibreOffice on Wayland via GTK3

What the Cell?! Unexpected things happening under the grid.

LibreOffice UI Concept A personal, user friendly and flexible interface

Introducing LibreOffice SafeMode

Make your LibreOffice extensions and macros rock Defining user interface has never been easier

Extensions Ugly Toupee or Hipster Hairdo?

LibreOffice Online Debugging

Contextual groups in LibreOffice' Notebookbar How to make life easier for beginners

DrawingLayer - Optimization & Implementation See how we optimized drawinglayer performance with buf…

Schema Database Documentation Through Introspection

Web Development and Perl 6

Docker for Perl[56] People A Ridiculously Short Introduction

Informal Domain Specific Languages in Perl 6

Making Camelia Fly Faster

Changing the Image of Perl

Containers in Pure Perl

Notes from the Trenches Parsing Perl 6 *in* Perl 6

Perl 5.24, 5.26, and the Future of Perl 5

Building a Universe with Perl

Perl6 as a First Language

Hold my beer and watch this!

Simple Number Theory in Perl 6

Welcome to the Ruby Devroom 2017

What makes TruffleRuby run Optcarrot 9 times faster than MRI?

DIY: Home monitoring with Ruby & Pi

JRuby in 2017: Rails 5, Ruby 2.4, Performance We'll survey the work going on to make JRuby more com…

A People's History of the Ruby Garbage Collector Ruby GC from 1.8 until 2.4 and beyond!

Leverging Rust to Build a Windows friendly ecosystem for mruby

Highly Surmountable Challenges in Ruby+OMR JIT Compilation

Scientific Computing on JRuby

What's new in GStreamer land The last 2 years and the future

concurrent-ruby modern tools explained

Open Source Support for TTML Subtitles Status Quo and Outlook

Live Streaming with Nginx, RTMP and Kaltura

Media Analysis tools How we check media files

AV1: Status update Progress, expected features and encoding gains

Modern Fuzzing of Media-processing projects Keeping media processing secure and stable

10 years of Open Source Innovation in Online Video What's been done, what's next?

High throughput CDR Rating Queues using CGRateS

AES67 Open Media Standard for Pro-Audio Networks

Jitsi: state of the union What's new in Jitsi and its related projects

JsSIP: SIP in your browser

AES70 Open Control Standard for Pro-Audio Networks

QoS Challenges for Real Time Traffic Deployable QoS Using the NEAT System

RTC Analytics with HOMER 6 + Big-Data Export, Analyze and Alert RTC using HOMER and your favorite B…

Metre Border Guard for XMPP Security Domains

OpenSIPS - an event-driven SIP routing engine

FreeSWITCH, SIP and WebRTC Load Balancing and High Availability FreeSWITCH in Real World

Fundraising and Crowdfunding for FreeRTC Helping developers who work on RTC full time

Free communications on the desktop The case of Telepathy

Asynchronous event/state notifications in the Janus WebRTC server Providing administrators and deve…

Using XMPP to Connect and secure the world of IoT XMPP backed IoT

Introducing mediasoup A WebRTC SFU for Node.js

Conversations in a dual stack world IP and the old IP together - what can go wrong?

Telepathy-Bell Telepahty Connection Manager for Ring.

WebRTC and speech recognition services

Real-Time Chat on the Web How to use XMPP and Converse.js to integrate webchat into any website

The challenges and secrets of the realtime world What are the main technologies, frameworks and pro…

The distributed systems behind Ring BlockChain and OpenDHT

Scalable Asterisk Servers in a Large SIP Infrastructure

WebRTC - Low barrier to entry. Low barrier to exit?

GPAC: delivery of VR/360 videos using Tiles

Real Time Communication Improving Real Time Communication with free software

Open Media devroom introduction

Overview of Upipe modules for broadcast professionals

Dissecting media file formats with Kaitai Struct

Creating a LITE transcoding Workflow with OSS Ffmpeg, PHP, NodeJS, Jquery

Adding 16-bit Character Support in LLVM

Open Media devroom wrap-up What's next?

Security Enhanced LLVM

GlobalISel - LLVM's Latest Instruction Selection Framework

LLVM at Red Hat How and where is LLVM used in the Red Hat ecosystem

Convergent functions and function parameters SPMD semantics for GPU programs

Using clang as a Frontend on a Formal Verification Tool

Profile-Guided Optimization in the LDC D compiler Implementation and Benefits

LLD from a user's perspective

LuaJIT for AArch64 and MIPS64 platforms Improvements and the status

Mutation Testing Leaving the Stone Age

LuaWt Lua bindings for a C++ Web Toolkit library

Using LNT to track performance

Quick functional UI sketches with Lua templates and mermaid.js

A different Lua JIT using Eclipse OMR Using the Eclipse OMR JitBuilder to improve Lua performance w…

My BSD sucks less than yours

Making wearables with NodeMCU

GELIBoot Booting FreeBSD from encrypted disk

Next Generation of the LuaRocks test suite

Packaging Go in pkgsrc

CloudABI for FreeBSD How does it work?

Transport Evolution on top of the BSD's A New, Evolutive API and Transport-Layer Architecture for t…

0xFF Drawing games for a DIY console

Rapid backend prototyping for a geolocation-based mobile game With OpenResty, Redis and Docker

openEMSstim Open-source muscle stimulation for interactive experiences & games

Tablexia Cognitive Training for Children with Dyslexia

Computer games – not as easy as it looks

Polymorph A libre game engine based on Ogre3D and Puredata

Escoria, a libre point'n'click framework using Godot Engine "Oh, it looks just like SCUMM!" -- Tim …

Drawing based game design

WebCam based games OpenCV in practice: example for developers and business

Snap! Build Your Own Blocks Interactive visual programming

Goal Rush Creating a game with Monogame and other open source software

Can open source open minds? Lessons learned making games about diversity for the IncLudo project

Creating GPL'ed multimedia assets

Hero.Coli, learning synthetic biology by playing: an update Open Source, Open Data, Open Science

Iotivity from devices to cloud How to make IoT ideas to real using FLOSS.

Living Orb Tangible game console.

Does your coffee machine speaks Bocce Teach your IoT thing to speak Modbus and it will not stop tal…

Open Smart Grid Platform presentation An Open source IoT platform for large infrastructures

JerryScript An ultra-lightweight JavaScript engine for the Internet of Things

Internet Of Things Devroom Opening Overview of the day and Pieter Hintjens in memoriam

On the way to a FOSS Platform for Cloud Based IoT Solutions

Yocto based IoT device

Warp10: A new paradigm for Time Series analysis

Building distributed systems with Msgflo Flow-based-programming over message queues

Frosted Embedded POSIX OS A free POSIX OS for Cortex-M embedded systems

Project Lighthouse A low-cost device to help blind people live independently

6LoWPAN in picoTCP And how to support new Link Layer types

ADEM Collaborative air pollution monitoring

Scientific MicroPython for Microcontrollers and IoT IoT programming with Python

Playing with the lights Control LIFX WiFi-enabled light bulbs

libre.sh helps you to host your FLOSS Get up and running with libre.sh in 20mins \o/

guifi.net An Open, Libre and Neutral Telecommunications Network Based in Commons

The Internet Cube / La Brique Internet

[caliopen] Privacy index metrics in digital communication Showing to Caliopen's users how public th…

Puffin Free Webapp Hosting for Average Users

[diaspora] The state of diaspora* and the decentralized social world The Federation is alive!

FFDN 5 years of DIY Internet accesss

The future of decentralised communication, identity and reputation with Matrix

Let's de-Google-ify the Internet FLOSS: Positive Alternatives to Big-Data centralized Services

[nextcloud] Cloud Federation sync, share & collaborate in a decentralized cloud

Making the GAFAs obsolete Decentralizing the servers with the personal cloud approach. Introduction…

[freifunk] Access is a human right

Privacy in practice for self hosting

[cozy] Decentralize & Recentralize on Cozy Learn the real value of your data, using cozy

HelenOS in the year of the fire monkey

FreedomBox, liberty inside the cloud. Run your own life. Host your freedom. Connect with people.

Introducing kernel-agnostic Genode executables

Deterministic replay support for Genode components Performance penalty and challenges

Secure Microkernel for Deeply Embedded Devices

TCP/IP for MINIX, the good, the bad, the ugly

OpenWISP2 a self hosted solution to control OpenWRT/LEDE devices

The VFS paradigm from the perspective of a component OS

Virtualization on the Hurd

Redox OS A safety-first microkernel developed in Rust

Opening up accessible design

Accessibility in Open Source Accessibility in Open Source

A kernel in a library Genode's custom kernel approach

Welcoming and Introduction

Finding your users’ needs Researching motivations, activities and problems of your users

Developers looking for designers? Pitch your project! [Group]

Our Open Source Design collective [Group] + group photo! :)

When Cultures Clash Integrating UX with FOSS Development

Promoting your FOSS project to university student designers

Beyond that fancy logo Reaping the full benefits of design contributions

Why should we take an interest in Open Design? Thoughts and initiatives to open the creative process

Designing MuseScore My experience with doing UX design with local volunteers

Success Stories from the OSD community

Architectural font digitisiation and design Typographic pipeline with Graphviz, Inkscape and Fontfo…

Mozilla Open Design What we learned in 2016

Designing in the open - The UX of UX How does this thing called open source design work, or doesn't…

Get designers involved in your open source project! 💻 + 🎨 = 🙂 how we do it at Nextcloud

Design feedback in Open Source

Interviews as user research How I built a public transportation UI using interviews

Incremental Backups Good things come in small packages!

Disaster Recovery management with ReaR and DRLM DRLM Workshop

Relax-and-Recover Automated Testing

Interacting with Bareos Using Bareos Console commands to automate tasks

Bareos - Backup Archiving REcovery Open Sourced - Overview

First steps with Relax-and-Recover (ReaR) Understand how ReaR works by running it yourself.

Introduction to Bareos Backup Python Plugins How to extend Bareos with Plugins written in Python

Future ideas for ReaR, DRLM, and Bareos Talk with ReaR, DRLM, and Bareos users about what they like…

Tutorial: my first hardware design Basic course to create a simple FPGA design using OSS tools

Welcome Word Backup and Disaster Recovery devroom Introduction and welcome word

GNOME Recipe App From Thinking On to Acting On

Essentials about Disaster Recovery with Relax-and-Recover A generic introduction for beginners

Footwork PCB designs as code and EDA as code synthesis

KiCad Project Status

Digital hardware design What can we learn from software development – and what not?

Kitnic.it and 1-click BOM Making web-enabled EDA tools using Javascript

Kubernetes on the road to GIFEE

Ruby bindings for Libgerbv Display and edit Gerber RS247X files the easy way

gnucap -- recent work and directions

Integrated Spice Simulation with Kicad

Diving into the KiCad source code

QUCS project update Overview, status and ongoing developments.

Everything You Always Wanted to Know About "Hello, World"* (*But Were Afraid To Ask)

FLOSS Tools for High Level Synthesis Integrating the FPGA into the Operating System

SpinalHDL An alternative hardware description langage presentation

GNU Radio Project Intro & Update manipulating one of the four fundamental forces of the universe

Networked-Signal Processing in OAI

Understanding JESD204B High-speed inter-device data transfers for SDR

SDR Panel: Which are the top 3 challenges for free software radio? An interactive session. Let's ta…

Overview of gr-inspector A Signal Analysis Toolbox for GNU Radio

FPGAs in SDR -- Why, when, and how to use them (with RFNoC) Taming digital hardware for software ra…

From 0 to 6 GHz in 30 minutes: Bootstrapping your SDR experience Start from scratch today, hack the…

Virtual multi-antenna arrays for estimating the bearing of radio transmitters

Receiving Wireless Mobile Traffic Lights

Monitoring the ionosphere altitude variation with a sound card software defined radio processing of…

Tensor Processing and Machine Learning for Signal Processing Functional Algorithm Definition and Co…

SDR, Ham Radio and the Debian Hams project Turn-key solutions for hams using Debian packages

SatNOGS An SDR-based Satellite Networked Open Ground Station

Open Source Map Rendering with Mapbox GL Native

Xorn: A new approach to scripting for gEDA/gaf

Intro to semantic annotations for geographic web maps in HTML Pulling Schema.org, Dublin Core, Micr…

GPU-Enabled Polyphase Filterbanks Everyday I'm Shuffling

Ethics in Network Measurements Moral obligations of engineers, scientists and hackers, based on ex…

Find the best place in the city Using City Focus, a web based 2D/3D GIS

'Open Notices' - alpha A global platform for official notices (planning, licensing etc)

Google Summer of Code 2016 @OSGeo

airspace-v.com international hangar flying

Big Spatio-Temporal Datacubes on Steroids ...and Standards

Khartis - How to simply create thematic maps in three steps

What to expect from MySQL 8.0?

Easily creating location-based applications with OSMAlchemy Learn how to create (web) applications …

German weather data with R

Creating georeferenced digital elevation models from unmanned aerial vehicle images

Working with spatial data in Go

Introduction to Boost.Geometry

Geography on Boost.Geometry The Earth is not flat (but it's not round either)

Into Geospatial Devroom

How to break the OpenStreetMap Pros and pitfalls of editing OSM data offline

Graphs at scale Scale out Neo4j using Apache Mesos and DC/OS

(Cypher)-[:ON]-❯(ApacheFlink)❮-[:USING]-(Gradoop)

Using graph databases in popular open source CMSs Neo4J and Drupal, potential application areas and…

Twitter Streaming Graph with Gephi Visualising stream of Data

Graph Analytics on Massively Parallel Processing Databases

Intro to Graph databases

Incremental Graph Queries with openCypher

From Shopping Baskets to Structural Patterns

Graph Processing on SAP HANA, express edition

Network Traffic Analysis of Hadoop Clusters Understand the common usage patterns and identify typic…

Mutants, tests and zombies aka mutation testing with Python and a pinch of Ruby

Using Containers for Building and Testing Docker, Kubernetes and Mesos

Designing a graph library for JavaScript

Future of Mobile Automation Testing, Appium steals it Mobile Testing Future

Infer A static analyzer for catching bugs before you ship

Can strace make you fail? strace syscall fault injection

Testing web applications with traffic control in containers

Declarative Pipelines in Jenkins A new way to define your pipelines in Jenkins

GitLab CI: (almost) effortless Open Source CI an introduction at how testing with gitlab CI is adva…

Do You Want to Retry? Handling and Testing Network Failures

Making Wiki Gardening Tasks Easier Using Big Data and NLP

Purely Functional GPU Programming with Futhark

Portability of containers across diverse HPC resources with Singularity

The birth of HPC Cuba How supercomputing is being made available to all Cuban researchers using FOSS

Kafka Streams and Protobuf stream processing at trivago

BigPetStore on Spark and Flink Implementing use cases on unified Big Data engines

Putting Your Jobs Under the Microscope using OGRT

Reproducible HPC Software Installation on Cray Systems with EasyBuild

Using BigBench to compare Hive and Spark versions and features BigBench in Hive and Spark

Postgres MPP Data Warehousing joins Hadoop ecosystem Making two elephants dance

Quickstart Big Data

You know what's cool? Running on billions of devices curl from A to Z

Intelligently Collecting Data at the Edge Intro to Apache NiFi and MiNiFi

Democratizing Deep Learning with Tensorflow on Hops Hadoop

Optimized and reproducible HPC Software deployment with free software and GNU Guix

The Marriage of Cloud, HPC and Containers

Not less, Not more. Exactly Once Large-Scale Stream Processing in Action.

A field guide to the machine learning zoo

Extending Spark Machine Learning Pipelines Going beyond wordcount with Spark ML

Dask - extending Python data tools for parallel and distributed computing

Why you should care about SQL for big data and how Apache Calcite can help #SQL4NoSQL

The Making of a Secure Open Source Password Keeper From the Electronics to the High Level Software.…

Closing FOSDEM 2017

WireGuard: Next Generation Secure Kernel Network Tunnel Cutting edge crypto, shrewd kernel design, …

Quantum computing and post-quantum cryptography a gentle overview

Securing Automated Decryption New Cryptography and Techniques

Portfolio of optimized cryptographic functions based on Keccak

Encrypting Matrix Building a universal end-to-end encrypted communication ecosystem with Matrix and…

Using Linux in Air Traffic Control Hardware and Operating System Platforms

It's time to SAFE the Internet Introducing SAFE, the decentralised privacy-first storage and commun…

Resurrecting dinosaurs, what can possibly go wrong? How Containerised Applications could eat our us…

All Ages: How to Build a Movement

Software Heritage Preserving the Free Software Commons

Welcome to FOSDEM 2017

CloudABI Easily develop sandboxed apps for UNIX

Understanding The Complexity of Copyleft Defense After 25 Years of GPL Enforcement, Is Copyleft Suc…

Next Generation Config Mgmt: Reactive Systems

Beyond WHERE and GROUP BY

Introduction to web development in C++ with Wt 4 A server-side web framework written in C++

New GPIO interface for linux user space GPIO character device API and libgpiod

OpenDaylight as a Platform for Network Programmability

How Carton, Docker, and CircleCI Saved my Sanity Or how I stopped using RPMs and learned to love Do…

Gutenberg to Google Fonts: the sordid history of typeface licensing issues Legal issues for project…

Researchers and Software Licenses The story of what we are doing at the German Aerospace Center (DL…

Automate oVirt Disaster Recovery Solution With Ansible See How Ansible Makes oVirt Recovery A Piece…

Let's talk database optimizers

What community can learn from marketing Community isn't marketing but there are things that develop…

Histogram support in MySQL 8.0

Managing build infrastructure of a Debian derivative

Instant ADD COLUMN for InnoDB in MariaDB 10.3+ On the way to instant ALTER TABLE of failure-free r…

Experiences with testing dev MySQL versions and why it's good for you

Mirai and Computer Vision Security and function of connected webcams

Documentation convergence project for LibreOffice Make just one documentation for all

The future of the internet from a Mozilla perspective Brought to you by Mozilla's executive chairwo…

Kodi and Embedded Linux Moving Towards Common Windowing and Video Acceleration

Releasing to CPAN and GitHub

Efficient Graph Algorithms in Neo4j

The Future of Copyleft: Data and Theory

FOSS Platform for Cloud Based IoT Solutions Eclipse-IOT FOSS Platform for Cloud IoT

Template toolkit translations

Welcome to the Perl devroom

IoT DevRoom Opening Overview of the day

Securing Embedded Systems using Virtualization

BaseDocumenter LibreOffice Base applications: how to document them, how to manage and analyze impac…

Perl in the Physics Lab

Stupid Pluto Tricks Real world things you can do with a PlutoSDR

ProxySQL - GTID Consistent Reads Adaptive query routing based on GTID tracking

MyRocks roadmaps and production deployment at Facebook

Introduction to Flatpak

Why We’re excited about MySQL 8

Proposal for better font handling in LibreOffice

Keys to deploy affordable virtual desktops with IsardVDI VDI solution from scratch optimizing all c…

BYOR: Bring-your-own-radio hacking session Bring your device, show us what it can do!

Flatpak and your distribution

Kernel Graphics Development on Remote Machines Accessing machines remotely with Open Source tools

MySQL 8.0 Performance: InnoDB Re-Design

Introducing BuildStream A distribution agnostic build tool

Recapping DARPA's First Big Hackfest

Capture the GDPR with Identity management Crafting Identity management tool to handle GDPR requirem…

... like real computers! Making distributions work on single board computers

diskimage-builder: Building Linux Images for Cloud / Virtualization / Container

Rustarm AKA A project looking at Rust for Embedded Systems Rust on embedded platforms

Adding support for a mouse in libratbag

Gnuk Token and GnuPG scdaemon

Hacking the JVM from Java

Automating Secure Boot testing

Surviving in an Open Source Niche: the Pythran case a compiler for scientific kernels written in Py…

Understanding 26 U.S.C. § 501, and Organizational Governance ... and why understanding all this mat…

C++ Code Generation with GRC

Handling Billions Of Edges in a Graph Database

Cypher: An evolving query language for property graphs A discussion of new extensions to Cypher

NFV a' la VDE way

Community & Business Two worlds, one galaxy

Adding performance counters to htop

Re-structuring a giant, ancient code-base for new platforms Making LibreOffice work well everywhere.

Sustainability of Open Source in International Development A new approach from the United Nations F…

Component Sourcing for Design and Manufacturing in Shenzhen An augmentation of Bunnie Huang's "Guid…

Improving the SecureDrop system architecture Good useability in a high security environment

Cockpit: A Linux Sysadmin Session in your Browser

The Invisible Internet Project An overview and guide to the technology

Building RT Linux distribution with Yocto

Wrap it Up! Packaging from Pots to Software

So you think you can validate email addresses A journey down RFC5321

Viva, the NoSQL Postgres ! Jsonb history and roadmap

Regular Expression Derivatives in Python

Emitter: Scalable, fast and secure pub/sub in Go Scalable and real-time networking for IoT, web app…

The Computer Science behind a modern distributed data store

Are distributions still relevant?

Optimizing Software Defined Storage for the Age of Flash

Moving PCI emulation inside of Xen Reasons and implementation of a PCI emulation layer inside of Xen

How to keep your embedded Linux up and running? Paint Your L[inux|awn] Green

Gnucap, and analog and mixed signal simulation

Logging IoT Know what your IoT devices are doing

Facing the Challenges of Updating Complex Systems Putting it all together

PostgreSQL Replication in 2018

Graal: How to use the new JVM JIT compiler in real life

Cyborg Teams Training machines to be Open Source contributors

Keeping It Real (Time) Real-Time Support in OpenStack

A Journey through Upstream Atomic KMS to achieve DP compliance Black Screens and how to prevent the…

G-CORE: The LDBC Graph Query Language Proposal

Top Ten Metrics for Evaluating your Garbage Collector

People can't care when they don't know Improving how major sites communicate licensing information

Analzying Blockchain transactions in Apache Spark

Wayland client basics How to natively speak Wayland in your application, from the bottom up

Graphic design tools for Open Source FPGAs Learn about the Apio and Icestudio projects

Developing an Open Source Hardware Laptop with KiCAD Using FOSS tools for designing an OSHW laptop

Funny digital electronics with Open Source FPGAs

Connecting the Edge Project Flogo as Ultra-lightweight IoT Apps framework

An Open Platform for Collecting data for OpenSeaMap The Proposed Platform Comprises Open Soft- & Ha…

FOSSology - OSS Project for License Compliance

Improvements around document signatures and encryption Signing and encrypting with OpenPGP, adding …

FOSS/H EDA tools for SPICE modeling

Calc: The challenges of scalable arithmetic how threading can be challenging

Dialog tunneling in LibreOffice Online

Ligato: a platform for development of cloud-native VNFs

Peeling onions: understanding and using the Tor network

Etienne Saliez - A look at “Natural Intelligence” IMMM Interactive Medical Mind Maps

Barometer: Taking the pressure off of assurance and resource contention scenarios for NFVI

Mozilla Open Source Support (MOSS) How Mozilla is helping open source projects like yours

Bugmark a futures market for software bugs and tasks, on the blockchain

Crowdsupply EOMA68 Progress Report A summary of the past year working on fulfilling the pledges fro…

Easy GnuPG Shell scripts to make GnuPG more accessible and easier to use

MySQL: Scaling & High Availability Production experience for the last decade

Next Generation Internet Initiative An opportunity to fix the internet

Igniting the Open Hardware Ecosystem with RISC-V SiFive's Freedom U500 is the World's First Linux-c…

The emPeerTube strikes back Let's decentralize YouTube !

4 Perl web services I wrote and that you may like

Networking deepdive From net.Dial to gRPC

A tour with Firefox' developer tools

Class Metadata: A User Guide

OpenADx – xcelerate your Automated Driving development Leveraging open collaboration and open sourc…

The current EU copyright reform proposal: the end of FLOSS in Europe?

Tomorrow's JavaScript Debugger How to shape your own JS debugger in 2018

An optimized GFDM software implementation for low-latency

IoT.js - A JavaScript platform for the Internet of Things

Physics, Math, and SDR Recognize, measure, and correct the inevitable

Moving from policy to action: Learning to live by our Community Participation Guidelines

Photon Performance How We Made Firefox Faster

Making a browser fast The story of Firefox Quantum

Fundraising and Crowdfunding for FreeRTC Community discussion about fundraising

WebExtensions API status after Firefox 57

Digital Archaeology Maintaining our digital heritage

Performance Analysis and Troubleshooting Methodologies for Databases

Kamailio - Pick Your SIP Routing Scripting Language

Google’s approach to distributed systems observability for Go

SIP based group chat with Linphone A discussion on how Linphone implements SIP RFCs to achieve te…

aiosip: the efficient swiss-army knife of SIP

Outsourcing Source Code Distribution Requirements

Asterisk Project: Do I see video in the future?

Starviewer: FOSS DICOM Medical Imaging Software Over 10 years fulfilling the daily needs of clinici…

OpenDHT: make your project distributed Use cases, new and upcoming features

Using CGRateS as online Diameter/Radius AAA Server

Highly Available Foreman A presentation about Highly Available Foreman including common pitfalls an…

Mallard, Pintail, and other duck topics topic-oriented help at the GNOME project

Automating style guide documentation How we at Zalando Retail Dept automated our Styleguide & sourc…

A lion, a head, and a dash of YAML Extending Sphinx to automate your documentation

Debugging A Live Gluster File System Using .meta Directory

How to build autonomous robot for less than 2K€ Build a robot doing Simultaneous Localisation And M…

Too young to rock'n'roll (and to contribute) Issues with minors (children) contributing to FOSS pro…

freeIPA installation using Ansible Description and examples of freeIPA client and server installati…

Terraform is maturing problems we've seen in puppet and their solutions

Free your Weather Station! War Stories from hacking Weather Stations

A decade of config surgery with Augeas

Measuring security and privacy on the Web The idea and use of PrivacyScore.org

Recycle Parsers With Grammar::Common in Perl 6

Using Cryptographic Hardware

RAWcooked Compress your DPX and revert without losing any metadata

Identity governance and data protection with midPoint

Tutorial: my first FPGA design Basic course to create a simple FPGA design using OSS tools

GPAC: Support for High Efficiency Image Format (HEIF)

Cooperative Communities Do we really have to set up a new community for every cause?

A Bug in Your Ear Patching the People Side

LibreOffice QA - One Year Overview What have happened between FOSDEM17 and FOSDEM18

Package Management Unites Us All

AV1 Codec Update

Handling media - the RESTful approach How we integrated media content in textual API

Current meta of video compression and probable futures ...or how to hammer things until they work b…

PostgreSQL -- A Crash Course

The path to Data-plane micro-services Software defined network functions are changing!

Finding a home for docs How to choose the right "path" for documentation in open source projects

Open Food Facts: the wikipedia of food products What if you could freely analyse all the food and c…

How compilers affect dependency resolution in Spack

Moby Project and Docker Inc — Balancing community and corporate needs

Why I forked my own project and my own company ownCloud to Nextcloud

Reasons to mitigate from NFSV3 to NFSV4/4.1

Ceph & ELK Use the power of the ELK stack to know more about your Ceph Cluster!

Introduction to Swift Object Storage Understanding the architecture and use cases

Package management over Tor

DRLM in Action! GNU/Linux Disaster Recovery, the open source way

GRUB upstream and distros cooperation

The UoC Radio Station Project Technical overview of an FM radio station based on open source and DIY

It's a Trie... it's a Graph... it's a Traph! Designing an on-file multi-level graph index for the H…

Hairy Security the many threats to a Java web app

Reimagining EDSAC in open source An valve computer reimplemented using FPGAs, Arduinos, 3D printing…

How to backup Ceph at scale

Piece of cake - testing remote embedded devices made easy using open-hardware MuxPi

Graphics Performance Analysis with FrameRetrace A Responsive UI for ApiTrace

Kubernetes load balancing for virtual machines (Pods)

Programming UEFI for dummies What I have learned while tweaking FreePascal to output UEFI binaries

Making Linux Security Modules available to Containers Stacking and Namespacing the LSM

Welcome Introduction to the containers devroom

Analyzing developers network in a community

The State of Containers in Scientific Computing

You want a Clean Desktop OS? Containerize it

Introduction to LXD clustering Multi-node deployments with one big virtual LXD

Kubernetes Security Best Practices

Turning physical systems into containers Migrating to system containers

Image capture on embedded linux systems

Testing for testing Using CI in the classroom

ARM64 + FPGA and more: Linux on the Xilinx ZynqMP Opportunities and challenges from a powerful and …

Advocating For FOSS Inside Companies

Software necromancy with Perl

Implementing state-of-the-art U-Boot port, 2018 edition How to port U-Boot to a new system using be…

Linux as an SPI Slave Adding SPI slave support to Linux

Comparative Law of Licenses and Contracts in the US, UK and EU

LLVM, Rust, and Debugging

Network Automation Journey A systems engineer NetOps perspective

How to cross-compile with LLVM based tools

Unix? Windows? Gentoo! POSIX? Win32? Native Portability to the max!

Heterogeneous Computing with D Using the PTX and SPIR-V targets with a system programming language

The half rolling repository model The golden intersection for desktop users?

Tizen:RT A lightweight RTOS platform for low-end IoT devices

Home automation - Not as simple as you think

ZX Spectrum in the New Millenium Upgrading ROM Cartridge to 512KB

Turning On the Lights with Home Assistant and MQTT

Claim Space, the Libre Way, using SDRs

The GNU Radio runtime Reinventing a very fast wheel

Testing in Rust A Primer in Testing and Mocking

webPh.one - connect community cellular networks using WebRTC and PWA Open Source , WebRTC and Web t…

The RTP bleed and what can we do?

MySQL Test Framework for Support and Bugs Work

MySQL InnoDB Cluster MySQL HA Made Easy!

Contributopia De-google-ifying is not enough

Linux Test Project introduction

Data integrity protection with cryptsetup tools what is the Linux dm-integrity module and why we ex…

Urban places as nodes of a decentralized Internet The MAZI toolkit and the Openki.net platform

Inside Monero The world's first fungible cryptocurrency

Perceval: Software Project Data at Your Will OSS development tools data extraction

Security Theatre The (mostly) unknown OSI Layer 8

Componolit - a component-based open-source platform for trustworthy mobile devices Deprivileging th…

GStreamer for tiny devices Making GStreamer small

The Chromium project's Way to Wayland

Making the web faster with the JavaScript Binary AST

Beyond the screen WebXR: when immersive content enters the Web

Your Open Source Community Metrics Should be Tracking More than Code

The AMD Linux graphics stack, 2018 edition

Java in a World of Containers

Shaders in radeonsi an update on dynamic linking and NIR

DWARF Pieces And Other DWARF Location Woes

horizon - a new star on the EDA sky

Package Management Panel Discussion Future of Package Management

Debug your build by tracing and reversing stracing your build from sources to binaries

Valgrind's Memcheck tool vs Optimising Compilers Keeping the false positive rate under control

Debugging realtime application with Ftrace

gdb tools: duel and @PrettyPrinter

Rust versus DWARF versus LLVM

strace: new features

DTrace for Linux

Status of the Apache ODF Toolkit (incubating)

Accessibility 101 (not only) for LibreOffice developers

Antipatterns in OpenOffice Code How can we ensure better Code

EPUB export in LibreOffice Writer

Lightning talk session Come and tell us your most recent hack - in 5 mins!

Good things come to those who wait - BorderFrames and WriterGraphics Armin will hold this talk

DNA sequencing performance in Go, C++, and Java

Computer Vision Using Go And OpenCV

Go Lightning Talks Come speak!

Testing and Automation in the Era of Containers (with Go)

Upspin and a future of the Internet My vision of Rob Pike's Upspin as a basis for a decentralized I…

Privacy aware city navigation with CityZen app The free open source app that let's you explore your…

ONAP – A road to network automation

LitOps: literature-as-software Briging DevOps culture to the creation and production of books

(Yet another) passive RADAR using DVB-T receiver and SDR.

Terra Bruciata where bugs cannot survive

Whisper and Swarm Protocol for RTC Decentralised, Distributed and Deniable, Communication.

Teleport: Local filesharing app

Building OSM based web app from scratch How to find the way through the open source jungle

Pronto Raster: A C++ library for Map Algebra

Mapping FOSDEM for accessibility

FOSDEM Infrastructure Review

Docs like code in Drupal Introducing Open DevPortal, an open source CMS based documentation tool

What's new in GStreamer?

Compiler-assisted Security Enhancement

Build your own Skype... in the browser A background to WebRTC

Writing a Janus plugin in Lua C can be a scary world, let us come to the rescue!

Live Block Device Operations in QEMU

The case for interface{} When and how to use empty interface

Optimized container live-migration Incremental live-migration of LXD system containers with CRIU

State of the rkt container runtime and its Kubernetes integration A look at the progress of rkt and…

Vectors Meet Virtualization challenges from our new data processing overlords

Device Assignment for VMs in Kubernetes

File access-control per container with Landlock

LTTng: The road to container awareness Kernel and userspace tracing in a containerized world

Test your API docs! It's tested or it's broken

DocBook Documentation at SUSE Automatically Ensuring Quality of SUSE Documentation

Artificial intelligence dealing with the right to be forgotten

O’PAVES: An open platform for autonomous vehicle tinkerers

Public money, public code, the Italian way Hacking Italian Administrations to get to the code (in a…

Interface Animation from the Future

Perl in Computer Music

Using KVM to sandbox firmwares from the Linux Kernel or: How I learned to stop worrying and love EF…

Thunderbolt 3 and Linux

LinuxBoot: Linux as Firmware Replace most of your firmware with Linux

Mainline Linux on Motorola Droid 4

Self-host your visual assets with Free Software Introducing Identihub

The case against "It just works" or how to avoid #idiocracy Design, education, politics and fake ne…

Pitch your project Present your FOSS project to designers and get them to contribute

Cultural interpretations of Design and Openness

Literate Programming meets LLVM Passes

The Open Decision Framework How to make everybody happy

GeoPandas: easy, fast and scalable geospatial analysis in Python

GRASS GIS in the sky GRASS GIS as high-performance remote sensing toolbox

Rendering map data with Mapnik and Python

Building Rock Climbing Maps with OpenStreetMap

Spatial Support in MySQL 8.0

Open source Big Geospatial Data analytics

Bicycle-sharing stations: profiling and availability prediction

Developing software on ORIC microcomputers OSDK, Oricutron & friends

LoRa Reverse Engineering and AES EM Side-Channel Attacks using SDR

Retro-uC An open source microcontroller with retro instruction sets

TiKV - building a distributed key-value store with Rust A transactional key-value store powered by …

Real Time Clustering with OpenSIPS Nodes of a feather gossip together

Ceph management with openATTIC

TLS for MySQL at large scale

SatNOGS: Crowd-sourced satellite operations Satellite Open Source Ground Station Network

Ring as a free universal distributed communication platform. The state of the project in 2018.

LizardFS - a year in development

Get your decentralized project some EU funding EU calls free software developers for "Future Hyper-…

Snabb - A toolkit for user-space networking

Sancus 2.0: Open-Source Trusted Computing for the IoT

Running Android on the Mainline Graphics Stack

Industrialisation of applications build in embedded environment How to build AGL (Automotive Grade …

Leveraging Software Defined Network for virtualization

Class Data Sharing Sharing Economy in the HotSpot VM

JVM startup: why it matters to the new world order

OpenMetrics - an industry standard for metrics Standing on the shoulders of titans

Fleet Commander: The efficient way of managing the Desktop profiles of your fleet! A brief descript…

SaMBa-AD, it works stories of battles fought and won

Firefox: How to ship quality software 8000 new patches, a release every 6 weeks, how Mozilla does i…

Intel GFX CI and IGT Motivation, what services we provide, and how do we integrate with development?

The open source EDA tool chain for the Chips4Makers project Is an ASIC made with fully open source …

Designing PCBs with code Designing circuits with code instead of CAD

Package quality assurance

Meet purl: a "mostly" universal software package URL that purrs. Or how to indentify & locate softw…

The package bazaars and the cathedrals Compare and contrast distro and app package and dependency…

Why hardware and operating system engineers need to talk

Rust On L4Re Safe Language Meets Safe Microkernel

Lightning talks

Microkernels in the Era of Data-Centric Computing

Towards capabilities in HelenOS The elephant in the room

Making the Ada_Drivers_Library: Embedded Programming with Ada

Writing REST APIs with OpenAPI and Swagger Ada

DWARF5 and GNU extensions New ways to go from binary to source

An update on VLC and the VideoLAN community VLC 4.0, VLC.js, VLC-VR?

LibreOffice for Haiku Port status

Maintaining accessibility through testing?

Update on GStreamer for Embedded Devices

Google’s approach to distributed systems observability for Go

Blue elephant on-demand: Postgres + Kubernetes

netmdev: mediated net_device Clean native userland access to net_devices from VPP, ODP, DPDK...

The challenges of XDP hardware offload

SRv6 Network Programming on FD.io VPP and Linux

LizardFS and OpenNebula, a petabyte cloud the simple way How to move OpenNebula into the Petabyte s…

Making electronics How to assemble open source electronics projects

GASdotto: a platform for ethical purchasing Matching freesoftware with ethical economy

War Stories from the Automotive FLOSS Front fun and pain doing FLOSS in the car

Introduction into the ppci project

Hidden Gems in Draw/Impress Part 2 Functionalities you didn‘t even know that you might need or did …

Distributed File Storage in Multi-Tenant Clouds using CephFS

GStreamer & Rust Fast, safe and productive multimedia software

Container Attached Storage (CAS) with OpenEBS A different approach to container storage

Spawny A different approach on logging in

The Fabulous Destiny of 0000000200000008000000BB

Fast Packet Processing in Linux with AF_XDP

ARB_gl_spirv: bringing SPIR-V to Mesa OpenGL Bringing SPIR-V to Mesa OpenGL

Drive your NAND within Linux Forget the word "nightmare"

Using TPM 2.0 As a Secure Keystore on your Laptop It's not as difficult as you think!

CryptPad Encrypted collaborative editing without trusting the server

Painless Puppet Providers

Rusty robots Programming a self-balancing robot in Rust

Unleashing the Power of Unikernels with Unikraft

Every subway network in the world

The RED Method: How To Instrument Your Services.

Technical Writing for Non-Writers

FreeBSD : pkg provides A plugin for querying which package provides a particular file

Presenting the Sympa Mailing List Manager and the new Sympatic CPAN module

Distributing OS Images with casync

A slightly different nesting: KVM on Hyper-V

The Generic Data Distribution System of the Retroshare Network An attempt to solve the problem of p…

Anonymous Whistleblowing with SecureDrop

Booting it successfully for the first time with mainline

Anatomy of the OpenOffice localization process And how to improve it in future

Exploring container image distribution with casync Experiments with the Content-Addressable Data Sy…

Finding your way through the QEMU parameter jungle

Everything you need to know about containers security Linux Containers and Docker security solutions

How to build and run OCI containers A shallow dive on the OCI container configuration and an overvi…

Organizer's Panel

Easy::jit: just-in-time compilation for C++

Cumin: Flexible and Reliable Automation for the Fleet Real life examples from the Wikimedia Foundat…

So we have free web fonts; now what? Open-source fonts dominate the web, but not print or embedded …

Welcome & Chatting

Improving GitLab's Navigation and Design System How we approached and strengthened our commitment t…

LLVM @RaincodeLabs Current and future uses of LLVM in Raincode Labs products

Our Open Source Design collective and group photo

DragonFFI Foreign Function Interface and JIT using Clang/LLVM

Icon Themes Reusable icon variables and mappings for customizable user interfaces

Join the FREEWAT family FREEWAT (FREE and open source software tools for WATer resource management)

Connecting LLVM with a WCET tool

Accessing your Mbed device from anywhere using Pagekite How to create a Mbed library for Pagekite

OSS-7: an opensource DASH7 stack When active RFID meets IoT and how to use DASH7 to build flexible …

Game development for the ColecoVision and Sega 8-bit systems Developing for Z80-based video game sy…

Efficient implementation of a spectrum scanner on a software-defined radio platform

Why you should take a look at Rust? Insights into a modern, safe, fast language

Rust - embedding WebAssembly for scripting WebAssembly in non-Javascript environments

Rust memory management A short intro

Introducing rust-av A pure-Rust approach to multimedia

Reaching const evaluation singularity An introduction into miri and Rust's const evaluation

Demystifying Rust parsing Language parsing and automatic binding generation

CephFS Gateways Distributed Filesystem Access via NFS and Samba

Developing applications with Swift as Storage System Learn about the API features to power up your …

Static Infrastructure Status with Jekyll and GitHub Pages

Can we measure the (de)centralisedness of the Internet with RIPE Atlas?

Geographically distributed Swift clusters

Introduction to the decentralized internet part

Servers can't be trusted, and thanks to tamper-proof journals EteSync doesn't need to!

Enroll 2FA to thousands of users with privacyIDEA Automating processes with privacyIDEA

Vis Editor: Combining modal editing with structural regular expressions

GrimoireLab: free software for software development analytics

The future of Sympa from mailing lists to social networks

Exploiting modern microarchitectures Meltdown, Spectre, and other hardware attacks

The story of UPSat Building the first open source software and hardware satellite

Android Real Life experience in Production How an application developer can survive in the chaotic …

Multitasking on Cortex-M class MCUs A deep-dive into the Chromium-EC OS

The OpenJDK Developer Experience

G1 - Not^H^H^HNever Done!

GrayLog for Java developers

Beyond string-based logging Structured logging with Serilog

What's new in Graphite 1.1

Samba authentication and authorization Introduction to Active Directory Auth protocols and winbind …

Why People Don't Contribute To Your Open Source Project

Samba AD in Fedora The long road to AD

A pixel format guide to the galaxy A tool for interpreting pixel format definitions

Proposal for an open and democratic Design Rule format A missing piece in the open source EDA world

Reflections on Teaching a Unix Class With FreeBSD Lessons learned on both sides

Open Build Service in Debian It is impressive how much time and resources a team can save

Maximizing UX for Customizing Improving user experience and accessibility of LibreOffice's Customiz…

Matroska Low-Latency streaming Why Matroska is (always) Better

Building a WebRTC gateway Hacking with WebRTC native API

JITing PostgreSQL using LLVM

De-mystifying contributing to PostgreSQL

Integrating cloud and container projects in the OPNFV community: Cross Community CI In this talk we…

Networking-VPP A fast forwarding vSwitch/vRouter for OpenStack

PBX on a non-specialized distro How and why we included an easy FreePBX setup in NethServer

EU-FOSSA 2 OSS bug bounties sponsored by the EU

Nakadi Event Broker An event broker with a REST API, on top of Kafka-like queues

Elasticsearch (R)Evolution You Know, for Search...

Writing Node.js Modules in Rust An introduction to Neon

Blame (and) DNS: debugging tutorial Find out who, where, and how broke your DNS.

Portable graphics abstraction in Rust Bringing Vulkan everywhere with gfx-rs

Idiomatic Rust Writing concise and elegant Rust code

Introducing gtk-rs Making the unsafe safe

Let's Fix The Internet

Easy Ada Tooling with Libadalang

ZFS: Advanced Integration Server, Laptop, Embedded, or Appliance -- ZFS is the Answer

Gluster-4.0 and GD2 Learn what's in Gluster's future

Introduction to LibrePCB A new, powerful and intuitive EDA tool for everyone

Distance computation in Boost.Geometry

Urbit: the personal server A clean-slate decentralized software stack.

Efficient and interactive 3D point cloud processing Combining the strengths of pdal, ipyvolume and …

Improving Linux Laptop Battery Life Reducing Linux Power Consumption

MySQL 8.0 Roles Giving direction to MySQL privilege system

Welcome to the Retrocomputing DevRoom A new devroom, for old tech

Orchestrator on Raft: internals, benefits and considerations

Turbocharging MySQL with Vitess

DNS privacy, where are we? A general examination of the current state of the DNS privacy project

What's new with FPGA manager Overview and Updates

DOSEMU and FreeDOS: past, present and future

SSSD: From an LDAP client to the System Security Services Daemon

i3 window manager A tiling wm for developers

Virtio 1.1 What's new in the next version of the Virtio standard

The Dynamo After Diffie Extending Disco-Era Crypto For Ubiquitous Secure Frameworking With Integral…

Dragonflow - An open network services ecosystem

Zonemaster Comprehensive tool for DNS validation

A crash course on remote, moderated usability testing

Configuring build base on FreeBSD Making things easy for the user

User-level networking on Genode

DLR-CAFE: CUDA Filterbank Updates Brand-New: Arbitrary Resamplers for everyone

DNSSEC for higher performace How aggressive use of DNSSEC-validated cache boosts DNS performace.

Will it blend? Comparison of oVirt, OpenStack and Kubernetes schedulers

Open Source BIOS at Scale We gave it a try, it worked. You can jump in!

Qt GUIs with Rust Rust Qt Binding Generator

Nexmark A unified benchmarking suite for data-intensive systems with Apache Beam

KiCad Version 5 New Feature Demo

NetBSD - A modern operating system for your retro battlestation

Living on the Edge Greatly needed stub resolver capabilities for applications and systems with the …

DNS-based discovery for OpenID Connect Taking Single-Sign-On to the next level

Forwarding system calls to userspace Using Seccomp to intercept system calls and forwarding them to…

Accelerating Big Data Outside of the JVM Adventures with Apache Arrow, Spark, BEAM, Flink, and frie…

Intro to Open Source Radio Telescopes

HOMER 7 Introducing the latest HOMER 7

A unique processor architecture meeting LLVM IR and the IoT

Zero Downtime Deployment with Ansible

NoSQL Means No Security?

Developing Enterprise and Community distributions at the same time, impossible ? openSUSE / SUSE ex…

Breaking with conventional Configuration File Editing Puppet with a Key/Value API in a User Study

Perl 6 on Jupyter

A Guided Tour of Eclipse IoT: 3 Software Stacks for IoT

OpenJDK Governing Board Q&A

Welcome to the Legal and Policy Issues devroom

In the SpOOTlight: gr-radar Measuring EM backscatter, free and easy

The State of OpenJDK

Intro Geospatial devroom

Qt in Automotive What does the Qt Automotive Suite do?

Containing container memory Snapshots and live migration with CRIU

Intro to the SDR Devroom ..and updates from the community

The MySQL Ecosystem - understanding it, not running away from it!

Speech-to-Text in Jitsi Meet Is it possible to provide WebRTC meeting transcriptions? Let's find ou…

Shared Memory Parallelism in Ada: Load Balancing by Work Stealing

containerd 1.0 Project Update the how, why, brief history of containerd, and its use today as a cor…

Productionizing Spark ML Pipelines with the Portable Format for Analytics

rustfix …and the journey to getting better code automatically

Closing FOSDEM 2018

Software Philanthropy for Everyone Engaging corporate philanthropy in free and open source software

Scaling Deep Learning to hundreds of GPUs on HopsHadoop

Ecosystems of Professional Libre Graphics Use

An Introduction to Ada for Beginning and Experienced Programmers

Building Decentralised Communities with Matrix Introducing Matrix Communities (and more!) as a dece…

How to write your own NIC device driver (and why) Our experience writing 10G/100G drivers for Snabb…

CrateDB: A Search Engine or a Database? Both! How We Built a SQL database on top of Elasticsearch a…

The circuit less traveled Investigating some alternate histories of computing.

Open communication in WebVR with Matrix! Where Matrix.org meets The Matrix...

Rapid SPI Device Driver Development over USB

Advanced Go debugging with Delve

Browser-as-GUI and Web Applications with Gnoga

Scaling messaging systems XMPP server MongooseIM and it's scalability options

AI on Microcontrollers uTensor brings Deep-Learning to MCUs

Nouveau Status Update

Distributions are not democracies and that's okay

Does data security rule out high performance? Is it possible to maintain the anonymity of people co…

The Julia programming language A look at arrays and Trilinos integration

Godot 3, libre gamedev for everyone The 2D and 3D game engine you've waited for!

Designing a Libre Embedded / Mobile RISCV64 SoC Distillation of the best features and pin-multiplex…

The Magnificent Modular Mahout An extensible library for distributed math and HPC

Scale Out and Conquer: Architectural Decisions Behind Distributed In-Memory Systems

Kids and Schools and Instant Messaging Experiences with free communications among kids and in educa…

How DeepLearning can help to improve geospatial DataQuality , an OSM use case.

The IoT botnet wars, Linux devices, and the absence of basic security hardening

Modules v4 Pushing forward user environment management

Python 3: 10 years later Looking back at Python evolutions of the last 10 years

Automated Linux Containers deployment for fun and profit. How we deploy system containers for our d…

Slurm in Action: Batch Processing for the 21st Century

GDAL Tips and Tricks GDAL installation, Python usage, and Cloud GeoTIFFs

Tools for large-scale collection and analysis of source code repositories Open source Git repositor…

Behind the scenes of a FOSS-powered HPC cluster at UCLouvain Ansible or Salt? Ansible AND Salt!

Modern tools to debug GStreamer applications

Distributing DevOps tools using GoLang and Containers, for Fun and Profit!

Testing Red Hat Enterprise Linux the Microsoft way Diving into Pairwise (a.k.a. all-pairs) test cas…

Lift your Speed Limits with Cython Fast native code for Python

XMPP as the road to innovation

Tying software deployment to scientific workflows Using Guix to make software deployment a first-cl…

Contract-based Programming: a Route to Finding Bugs Earlier

A real life story about product testing with robotframework Lessons learned testing IoT devices wit…

Testing and Validating distributed systems with Apache Spark and Apache Beam

Combining CVMFS, Nix, Lmod, and EasyBuild at Compute Canada

BIND 9 Past, Present, and Future The future is scary. But you can't just run back to the past becau…

Installing software for scientists on a multi-user HPC system A comparison between conda, EasyBuild…

XWiki: a case study on managing corporate and community interests 14 years of Open Source in a Smal…

High performance network functions with VPP

Rendering of subtitles in HTML5 with imscJS

Binary packaging for HPC with Spack

Repairing DNS at TLD scale DNS health in .CZ

SystemTestPortal A web application for managing manual system tests

Ada, or How to Enforce Safety Rules at Compile Time

Tips & Tricks to finance an Open Source Project without selling your soul

Advanced testing in action on a Java project Demonstrating testing practices using Java, Maven, Doc…

SPARK Language: Historical Perspective & FOSS Development

Load testing web services at Mozilla with Molotov http://molotov.readthedocs.io/

Migrating to Red Hat IdM in a large Linux Environment

Valgrind register allocator overhaul

i++: run your FOSS off Automatically counting laps at the 24 hour run in Leuven

Implementing a safe and auditable access to customer instances of your SaaS for the support staff w…

Working in the ODF TC

Asynchronous Decision Making - why and how How Asynchronous Decision Making works and why it's esse…

Piece of cake testing remote embedded devices made easy with MuxPi

Building an integration testing framework Integration testing framework we are building to test Git…

Rubber 'Duke' Debugging

Grafanalib - Dashboards as Code

Load testing with Locust

Observability: not just an Ops thing

Passing the Baton: Succession planning for FOSS leadership

The LTTng approaches to solving complex problems

Graphite at Scale at Criteo: BigGraphite Bye bye whisper !

Addressing the long tail of applications

Æ-DIR -- Authorized Entities Directory from paranoid user management to secure system management

Monitoring Legacy Java Applications with Prometheus

pot: another container framework based on jails and ZFS A personal/educational project to run conta…

Grafana Tips & Tricks & Whats New in v5

Wikilab, architecture & CNC Collaborative architecture and construction with FreeCAD

You’ve Got Some Explaining to Do! So Use An FAQ!

Declarative Extensions for Kubernetes in Go

Reducing CPU usage of a Toro Appliance

Packaging C/C++ libraries with Conan

Simplifying the contribution process for both contributors & maintainers A case study of the GitHub…

The many ways of using Guix packagesA guide to which ways might suit you

How To Make Package Managers Cry

Live sculpting a Genode-based operating system

LibreOffice's automatic updater work A progress report

Building and testing a distributed data store in Go

Make your Go go faster! Optimising performance through reducing memory allocations

Unix Architecture Evolution from the 1970 PDP-7 to the 2018 FreeBSD Important Milestones and Lesson…

Configuration Revolution Why it Needed 13 Years and How it Will be Done

IPC in 1-2-3 Everything you always wanted from a network, but were afraid to ask

Consensus as a Service Twenty Years of OSI Stewardship

Generic Graphics Tablets in Linux Hardware peculiarities, software challenges, and how to make them…

oVirt Metrics and logs - in a unified solution

Evolving Prometheus for the Cloud Native World

CBSD, Isolation manager How to manage jails, bhyve VMs and Xen via CBSD, while keeping it all simple

The free toolchain for the STM8 Getting into first place when non-free tools had years of head star…

Hurd's PCI arbiter

What's new in Upipe

Creating GopherJS Apps with gRPC-Web

Italy: the most hacker-friendly country? Developers Italia, what happens when a nation goes Open

OpenBSD as house alarm system Openbsd is not only good for network related projects

GPU resource multiplexing in component based systems

User Session Recording in Cockpit Introducing User Session Recording support in Cockpit - a server …

NetBSD and MercurialThe challenges of a long history

Networking Swiss Army Knife for Go

The FreeBSD Foundation and How We Are Changing the World

pkgsrc on ChromeOS

BulletinBoard DHT and wireguard-p2p

The MDN Browser Compat Data Project

syspatch(8)OpenBSD base system maintenance made easy

Native GTK3 UIprogress from gtk3 themed vcl widgets to native gtk widgets

Automated system partitioning based on hypergraphs for 3D stacked integrated circuits

Pulp 3 - Simpler, Better, More awesome

Media 101 for Communities

Everything is a device!Lessons learned from experimenting with MH

BSD from scratch - from source to OS with ease on NetBSD

Easily Secure Your Front and Back End app with Keycloak

Kodi v18 features and improvements What we've been busy with

Your Build in a Datacenter Remote Caching and Execution in Bazel

Cypher for Apache Spark

Moldable analysis with Moose

Source Code Analysis FOSDEM 2018

Melting the Snow Using Active DNS Measurements to Detect Snowshoe Spam Domains

Migrating code with SmaCC

Source Code Analysis FOSDEM 2018

JavaParser: where should we head? How to generate, transform, analyze, refactor Java code

Source Code Analysis FOSDEM 2018

Tree-sitter A new parsing system for programming tools

Source Code Analysis FOSDEM 2018

DIY Java Static Analysis Presenting the internals of SonarJava : a static analyzer for Java written…

Source Code Analysis FOSDEM 2018

Babelfish: a universal code parser for source code analysis

Source Code Analysis FOSDEM 2018

Finding inter-procedural bugs at scale with Infer static analyzer

Source Code Analysis FOSDEM 2018

Langkit: source code analyzers for the masses Reviving the meta-compiler dream

Source Code Analysis FOSDEM 2018

Parsing Posix [S]hell Yann Regis-Gianas

Source Code Analysis FOSDEM 2018

Graph-based analysis of JavaScript source code repositories

Source Code Analysis FOSDEM 2018

MethodHandles Everywhere!

The State of Go What's new in Go 1.10

More videos with Francesc

The State of Go What's new since Go 1.10

More videos with Francesc

Bringing monitoring into the 21st century

Caching and tuning fun for high scalability

Free Software A Viable Model for Commercial Success

Linux containers and OpenVZ

Hacking in the real world

XQuery 3 0 Rocks

An introduction to EclipseRT

semantic mediawiki

Libre fm and GNU FM Supporting free culture artists with free software

Powerful tools for Linux C C developers based on Eclipse

EPFSUG everybody needs a hacker

git annex manage files with git, without checking their contents into git

The Growl Project

Greenlight for girls

Geeklog The secure CMS

How we scaled up OpenQuake

FOSS in Broadcast

Q A with the FOSDEM staff

Threat Modeling Revolutionized

Gentoo ruby packaging

Succeeding in the Google Summer of Code as a large project

Multiarch - why it's important

fosdem2012 kashyap chamarthy dogtag

fosdem2012 paul bakker polarssl part2

Adventure of setting common account database for a distribution infrastructure

debtags debian net reloaded

Coping with wide impact changes in a distribution

fosdem2012 chris conlon yassl

Distributions infrastructure system administration round table Q A

How to replace a legacy tool with 100k installations

Caret and Stick

Univention Corporate Server

fosdem2012 benedikt heintel cacert

fosdem2012 anders rundgren open security hardware

Debian Secrets what I wish I knew before joining Debian

fosdem2012 tomas gustavsson cesecore common criteria

fosdem2012 paul bakker polarssl part1

Introduction to hardening, the Gentoo Hardened approach

Btrfs and Snapper

fosdem2012 branko majic x509 free software deployment

A New OSI for A New Decade

Multi OS Continuous Packaging with Project Builder org

Internet of Threads

You're doing it wrong

Why the community should welcome Average Jane and Joe

Implementing Domain Specific Languages with LLVM

Virtualization with KVM

QA tools for FOSS distributions

Re thinking system and distro development

Debian packaging for beginners

A strategy for managing diverse equipment in the CERN controls group

Native Linux KVM Tool

Voice Applications for the Modern Open Source Hacker

Working with contributor communities round table

The Wild West of UNIX I O

Arthur Huillet Anatomy of a role playing game

Fighting I/O: a story of Firefox startup speed improvements

mozilla sun1330 mozmill skupin

security 1300 intro paljak

security 1415 libcurl stenberg

security 1315 smartcard poure

security 1345 ssh adamantiadis

security 1445 cyassl stefonic

security 1500 fribid borell

security 1530 ejbca gustavsson

security 1600 pkcs11 mavrogiannopoulos

security 1630 trust walter

android video streaming

security 1700 systemtap kunysz

security 1730 dynalogin pocock

security 1800 opensc paljak

Sahi: automated cross-browser web testing

Mongrel2: Lighting up IPv6

PageKite: Making The Web 1000x Bigger

Forban: a simple link-local opportunistic p2p free software

Apache Etch: Efficient and feature-rich network services

Coreboot: x86 system boot and initialization

firefox4, new features for userd and developers

Django's architecture - the good, the bad, and the ugly

Data as a service with infinispanfull

PL/Parrot: Cutting Edge Free Software

golang, practical Go Programming

openstack building a free massively scalable cloud computing platform

qt webkit goes Mobile

objectc, Not just for Macs and iPhones

devops More than Marketing

Opening talk FOSDEM 2011

Why Political Liberty Depends on Software Freedom More Than Ever

webODF, an office suite built on browser technology

I'm going M.A.D

How kernel development goes wrong and why you should be a part of it anyway

calligra Under the Hood

The life of a firefox feature

linux disaster recovery with rear

Liberating Open Office Development

systemd, beyond init

The Storage Technologies Behind Facebook Messages

jpoker: a pure javascript poker client

OpenERP: Design applicactions with OpenObject in minutes

QuBit: Introducing Quantum Superpositions

UmlCanvas: bringing UML diagrams to the web

Kerrighed: Flexible distributed checkpoint/restart

Wt::Dbo: a C++ ORM (Object Relational Mapping) library

Padre, the Perl IDE: Building an open source team, getting the project to users against the odds

Cloudlets: universal server images for the cloud

Open-source software: Blaming the unknown, or a constructive approach to technology

Coccinelle: Finding bugs in open source systems code

asterisk: An introduction to Asterisk Development

The Wiki for Open Technologies: How to share your projects and knowledge

CAcert: Client-certificates and SSO - the old-new thing

Kaizendo.org: Customizing schoolbooks the free software way

Kamailio (OpenSER) 3.0.0: redefinition of SIP server

csync: Roaming Home Directories

GeeXboX: An Introduction to Enna Media Center

Faban: Developing benchmarks and workloads using Faban 1.0

SyncEvolution: From the SyncML Protocol to Free and Open Implementations

shadowcircle: a pentesting distribution alternative

Uzbl: A webbrowser which adheres to the unix philosophy

LiMux: 5 years on the way to free software in Munich

OpenPCF: An Open Provisioning and Control Framework

CiviCRM: Common goals of FOSS and Not For Profit Organisations

PortableApps.com: The PortableApps.com Platform, an Introduction and Overview

Qi Hardware's Ben NanoNote: open to the bone device

GNU Savannah: 100% free software mass-hosting

tinc: the difficulties of a peer-to-peer VPN on the hostile Internet

Welcome to FOSDEM 2010

Beernet: Building peer-to-peer systems with transactional replicated storage

SIP Communicator: Skype-like conf calls with SIP Communicator

Inside StatusNet: How Identi.ca Works

MINIX 3: a Modular, Self-Healing POSIX-compatible Operating System

Large scale data analysis made easy - Apache Hadoop

Evil on the Internet

What is my system doing - Full System Observability with SystemTap

Promoting Open Source Methods at a Large Company

RepRap - Manufacturing for the Masses

Tor: Building, Growing, and Extending Online Anonymity

Javascript charting with YUI Flot

Maemo 6 security framework, making happy DRM business and freedom lovers with the same device

MooTools as a General Purpose Application Framework

Postgresql: Lists and Recursion and Trees (oh my)

MariaDB: extra features that make it a better branch of MySQL

The Nmap scripting engine

The Ruby and .NET love child

Ganglia: 10 years of monitoring clusters and grids

Write and Submit your first Linux kernel Patch

CouchDB! REST and Database!

Building High Performance Web Applications with the Dojo Toolkit

Scaling Facebook with OpenSource tools

Starting the sysadmin tools renaissance: Flapjack + cucumber-nagios

ACPI and Suspend/Resume under coreboot

Systems management with RHQ and Jopr

Coreboot and PC technical details

Polishing X11 and making it shiny

Distribution Image building with KIWI

The free software desktops graphics driver stack

Cross distro packaging experience with the openSUSE Buildservice

GPU Userspace - kernel interface & Radeon kernel modesetting status

Cross distro packaging with top git

Translations of package descriptions

How to be a good upstream

Debian Secrets power tools for power users

Infrastructure round table

Distribution HR management

Debian and Ubuntu

Spacewalk Linux Systems Lifecycle Management

Working with GNOME upstream

YaST Future Roadmap

Fedora Governance

The Evolution of MonoTorrent

Fedora fr and upstream French communities

Hermes Message Dispatching

Building The Virtual Babel: Mono In Second Life

The youri project

Config Model and configuration upgrades during package upgrade

Image processing with Mono.Simd

ParallelFx, bringing Mono applications in the multicore era

Continuous Packaging with Project Builder org

Cross distro dependency resolution reusing solvers among distros

Linux distribution for the cloud

Mobile distributions and upstream challenges

NixOS configuration system

Packaging perl and CPAN modules

RPM packaging collaboration

The Maemo Community Council a case study in governance

Transactionally Protected Package Management

Moonlight and you

OSCTool - learning C# and Mono by doing

Smuxi - IRC in a modern environment

FOSDEM 2009 Apache felix

FOSDEM 2009 FreedroidRPG

FOSDEM 2009 Games engines done good

FOSDEM 2009 Custom OpenSolaris

FOSDEM 2009 Bug

FOSDEM 2009 Gemvid

FOSDEM 2009 Hyves Puppet

FOSDEM 2009 Camelot

FOSDEM 2009 eZ Find

FOSDEM 2009 FLOSSMetrics

FOSDEM 2009 LXDE

FOSDEM 2009 Marionnet

FOSDEM 2009 Linux Defenders

FOSDEM 2009 ModularIT

FOSDEM 2009 Mobile Development

FOSDEM 2009 MuseScore

FOSDEM 2009 Opsview

FOSDEM 2009 Pyroom

FOSDEM 2009 Secure List Server

FOSDEM 2009 OSI

FOSDEM 2009 SmallMail

FOSDEM 2009 LTS

FOSDEM 2009 Xwiki

FOSDEM 2009 CalDAV - the open groupware protocol

FOSDEM 2009 TikiWiki

FOSDEM 2009 Debian

FOSDEM 2009 Usbpicprog

FOSDEM 2009 FreeIPA, Identity Management

FOSDEM 2009 - 10 cool things about Exherbo

FOSDEM 2009 Fusil fuzzing

FOSDEM 2009 Google Summer Of Code

FOSDEM 2009 OpenAMQ

FOSDEM 2009 Ext4

FOSDEM 2009 MediaWiki

FOSDEM 2009 Help my system is slow

FOSDEM 2009 Welcome

FOSDEM 2009 Cobbler & Koan

FOSDEM 2009 Scala - A Scalable Language

FOSDEM 2009 The Fedora Project

FOSDEM 2009 Zarafa

FOSDEM 2009 Free and Open Future

FOSDEM 2009 OWASP Web Testing Methodology

FOSDEM 2009 Reverse Engineering of Proprietary Protocols, Tools and Techniques

FOSDEM 2009 MySQL High Availability Solutions

FOSDEM 2009 Upstart

FOSDEM 2009 Syslinux and the dynamic x86 boot process

FOSDEM 2009 openSUSE Welcome

FOSDEM 2009 openSUSE Cross Build

FOSDEM 2009 openSUSE Collaboration

FOSDEM 2009 openSUSE Community

FOSDEM 2009 openSUSE Studio

FOSDEM 2009 openSUSE Netbooks

FOSDEM 2009 openSUSE Apport

FOSDEM 2009 openSUSE Wine

FOSDEM 2009 openSUSE Zypper

FOSDEM 2009 openSUSE cdn

FOSDEM 2009 openSUSE Education

FOSDEM 2009 openSUSE Legal

FOSDEM 2009 openSUSE openfate

FOSDEM 2009 openSUSE Yast

FOSDEM 2009 openSUSE KDE

Theming in GNUstep Richard Frith Macdonald FOSDEM 2009

ScalableOGo Helge Hess FOSDEM 2009

Web Services in Objective C Richard Frith Macdonald & Riccardo Mottola FOSDEM 2009

FOSDEM 2009 openSUSE Gnome

Etoile David Chisnall (via iChat) & Damien Pollet FOSDEM 2009

Garbage collection with Objective C Richard Frith Macdonald FOSDEM 2009

GAP Applications + PRICE Riccardo Mottola FOSDEM 2009

Building Server Applications using Objective C and GNUstep Nicola Pero FOSDEM 2009

Building a Database Application with (almost) no Code Lars Sonchocky Helldorf FOSDEM 2009

Lenny_the_past_and_the_future___Luk_Claes

Apt_Xapian_Index___Enrico_Zini

How_accessible_is_Debian___Samuel_Thibault

Cross building_Debian_and_Tdebs___Neil_Williams

Persistent_device_naming___Frans_Pop

The_Belgian_electronic_ID_card_in_Debian___Wouter_Verhelst

fosdem08_day1_04_buildservice_webclient

Update_on_Virtualization_in_Debian___Henning_Sprang

fosdem08_day2_02_gnome

git___Pierre_Habouzit

The_long_road_to_Debian_Edu_in_main___Holger_Levsen

fosdem08_day1_02_coolo

fosdem08_day1_06_basesystem

fosdem08_day1_05_buildservice_bestpractices

fosdem08_day2_01_kde4

fosdem08_day2_03_energystar

fosdem08_day2_04_hal_dbus

fosdem08_day2_07_yast

fosdem08_day2_05_suspend

fosdem08_day2_06_kiwi

fosdem08_day2_09_1click

fosdem08_day2_08_satsolver

fosdem08_day2_10_redirector

fosdem_2008 _daniel

fosdem_2008 _bridgman

fosdem_2008 _eich

fosdem08_day2_11_accessibility

fosdem_2008 _gallium

fosdem_2008 _helge

fosdem_2008 _michael

fosdem_2008 _intel

fosdem_2008 _nouveau

FOSDEM 2008 scons

FOSDEM 2008 dacco

fosdem_2008 _remi

FOSDEM 2008 ajatus

FOSDEM 2008 alfresco

FOSDEM 2008 bluepad

FOSDEM 2008 eff

FOSDEM 2008 coherence

FOSDEM 2008 cloudbridges

FOSDEM 2008 archetype

FOSDEM 2008 ganeti

FOSDEM 2008 bongo

fosdem08_day2_12_zeroconf

FOSDEM 2008 foresight

FOSDEM 2008 ggz gaming zone

FOSDEM 2008 indywiki

FOSDEM 2008 iogrind

FOSDEM 2008 k3d

FOSDEM 2008 mamona

FOSDEM 2008 opentc

FOSDEM 2008 openafs

FOSDEM 2008 polippix

FOSDEM 2008 squeak

FOSDEM 2008 project indiana

FOSDEM 2008 sepia

FOSDEM 2008 tangogps

FOSDEM 2008 stylebaseeclipse

FOSDEM 2008 swpat

FOSDEM 2008 terracotta

FOSDEM 2008 view os

FOSDEM 2008 wir3d

FOSDEM 2008 tuxwithshades

FOSDEM 2008 welcome

FOSDEM 2008 openqrm

FOSDEM 2008 zapcat

FOSDEM 2008 xmms2

FOSDEM 2008 conary

FOSDEM 2008 cakephp

FOSDEM 2008 globulation2

FOSDEM 2008 crystalspace

FOSDEM 2008 hudson

FOSDEM 2008 jruby

FOSDEM 2008 klik

FOSDEM 2008 largescale

FOSDEM 2008 mozprism

FOSDEM 2008 packagekit

FOSDEM 2008 perl6

FOSDEM 2008 virtualbox

FOSDEM 2008 webscarab

FOSDEM 2008 wesnoth

FOSDEM 2008 xen

FOSDEM 2007 Drupal

FOSDEM 2007 Xorg

FOSDEM 2007 LinuxBios

FOSDEM 2007 Status of Software Patents in Europe

FOSDEM 2007 BeyondGPLv3

FOSDEM 2007 Welcome

FOSDEM 2007 OLPC

FOSDEM 2007 SecurityTesting

FOSDEM 2007 Mozilla

FOSDEM 2007 Metasploit

FOSDEM 2007 Bacula

FOSDEM 2007 SecureCommunicationsWithJabber

FOSDEM 2007 Samba

FOSDEM 2007 Plone

FOSDEM 2007 Liberating Java

FOSDEM 2007 Thanks

FOSDEM 2007 ReactOS

FOSDEM 2007 AIGLX

FOSDEM 2007 ProfilingDesktopApplication

FOSDEM 2007 JBoss

FOSDEM 2007 GEGL