FOSDEM welcome and opening talk.

Welcome to FOSDEM 2021!

A brief introduction to our devroom and the schedule ahead.

Welcome to the Raku devroom at FOSDEM 2022!

A brief introduction to the room and to the sessions.

This year's TEE devroom will again be a full-day virtual event with an impressive lineup! The day will be roughly divided into session blocks grouping related talks as follows:

10h00-12h25: TEE attacks, defenses, and enclave shielding runtimes

featuring an enclave exploit analysis, Guardian, Gramine, Enarx, and Veracruz

13h25-14h40: Emerging TEEs and best practices

featuring logging in confidential computing, secure boot, and ARM CCA

14h55-16h10: OS and and page-based isolation

featuring FlexOS, Intravisor, and EDP for AWS Nitro

16h30-17h30: Wrap up and discussion on process-based abstractions for VM-based environments

we wrap up the day with a live presentation and a following discussion

A brief introduction and overview of what you can expect from the MariaDB devroom at FOSDEM

The Jitsi project was founded almost 20 years ago, under a different name and just for academic purposes.

Almost 20 years later, the project could not be in a better shape! It has gone through a name change and several acquisitions by large corporations, while remaining current in the industry and innovating all along.

This presentation will take a trip down memory lane and see where Jitsi came from, how it has managed to stick around for so long, and what the future holds.

Every year we take some time to introduce the Open Source Design collective, what we do, where to find us and how to get involved.

A warm welcome from your devroom managers, practical information, lineup and administrivia. Happy Testing!

What if all our decentralized apps and platforms could share trust/ratings/attestation information, in the form of portable cryptographically signed claims? What if this self-sovereign, user owned and controlled, privately sharable trust network could become the backbone to unite our many disparate decentralized web apps and platforms? These are the goals of Trust Graph, and its reference implementation built on Holochain.

In this talk we will cover:

• TrustAtom format: source, target, semantic content, normalized scalar value
• Quick survey of the ecosystem of similar protocols
• Use cases, including the potential to tackle major global challenges
• An example illustrating Trust Graph "rollups" for caching Trust Graphs in TrustAtoms
• Trust Graph on Holochain: using Holochain links to allow for searchable TrustAtoms

Working with Big Data means that we need tools to organise and understand the data. And you don’t have to be a developer to search, aggregate and visualise your data. Whether you need an affordable business analytics tool or you want to analyse log data in near real time, OpenSearch can help you. And all of it through a visual interface of OpenSearch Dashboards.

After listening to this talk you’ll understand the basics of working with an OpenSearch cluster and different use cases it supports. You’ll also learn to create your first search and aggregation query and visualise the outcomes with the help of OpenSearch Dashboards.

This talk is for those who have little or no previous experience of OpenSearch (and Elasticsearch) and who are looking for solutions for searching, monitoring or data analysis with no coding required.

In this session the audience will get theoretical and a knowledge on what OpenSearch is, which use cases it supports and how the audience can start using it for their data already today. Roles outside of developers are welcome, the information will be presented in uncomplicated terms and we’ll use visualisation tools to create and run requests, so no coding is required.

CUE (https://cuelang.org/) solves a previously unsolved technical problem in the configuration space. It does so by taking a compositional approach that reduces the complexity of managing configuration from a combinatorial problem to a linear problem. CUE is based on 20 years of experience in the field of configuration. Its declarative, aspect-oriented approach is powerful yet simple, making it possible to manage large amounts of configuration data and policies in multiple formats (JSON, YAML, Protocol Buffers, OpenAPI, etc.) with relative ease. It also makes CUE well suited to a wide range of applications.

This all sounds great! But for someone new to CUE, it may not be obvious how to get started.

In this talk, Marcel van Lohuizen and Paul Jolly start with a quick overview of CUE the language, then move on to present practical examples of CUE in action, including common patterns for validation, policy, integration with existing non-CUE configuration and more. Because CUE is new, established patterns are still in the making, but at the very least it will be a reflection of the current thinking.

No previous experience of CUE required, although familiarity with an existing configuration and data languages will help provide some context to the examples.

Believing a system is safe is not the same as knowing it meets all the criteria defined to demonstrate that safety. Too often is the argumentation around the safety of a system presented as a document for humans to agree on, which is disconnected from the mechanism of asserting compliance with that argumentation. Subplot is a tool for processing documents containing such argumentation along with verification scenarios which are both human and machine readable so that this disconnect can be resolved.

This talk introduces Subplot and describes the concept.

Software engineers usually understand requirements and testing against requirements. All too often though, those responsible for the safety of a system do not understand how to express requirements which can be understood by engineers, such that the system can be verified. This could be for a myriad reasons, but usually it is due to a gulf between those who are specifying how to determine that a system is safe, and those who are implementing the system.

Subplot demonstrates how stakeholders at all stages of system design and implementation can come together to maintain a document which describes the criteria which, if met, demonstrate compliance with the safety argumentation made about the system. This document can then be rendered as a PDF or some stand-alone HTML for presentation to non-engineer stakeholders for confirmation.

Subplot can also generate a test program, from such a document, that when run will perform all of the verification scenarios contained in the document and produce a final report.

While Subplot is fairly new software, still under active development, the concepts in Subplot are built on those explored in a decade-old previous project, by the same authors, which considered similar problems purely from a software engineering perspective, used a similar Gherkin-inspired language and Markdown input structure, and was used in a variety of projects for paying customers; proving the concept works.

Subplot is a refinement of this older implementation.

LibreOffice was announced in 2010. After 10 years, it was necessary to review and update the strategy based on the evolution of the office suite market, to improve the sustainability model. Enterprises are not supporting the project as much as individual users. Over time, this can represent a threat for the sustainability of the project. We have changed our strategy to educate enterprises about the right approach to FOSS, by giving back to ensure the long term sustainability of the LibreOffice project.

LibreOffice was announced in 2010 to relaunch innovation of the already stagnant OpenOffice project. After 10 years of growth, it was necessary to review and update the strategy based on the evolution of the office suite market, to improve the sustainability model. In fact, enterprises - although deploying LibreOffice to save money over proprietary solutions - are not supporting the project as much as individual users. Over time, this can represent a threat for the sustainability, as development can be slowed down. We have therefore changed our strategy to educate enterprises about the right approach to FOSS, by giving back in one of the many available ways: purchase the LTS version from the ecosystem, fund the development of a specific feature, pay for the solution of a bug or a regression, and so on. The right approach from enterprises would ensure the long term sustainability of the LibreOffice project, and the evolution of the Open Document Format (ODF) ISO standard file format for true interoperability.

The Open Research Tools and Technologies devroom managers welcome words announcing the schedule.

This years the Open Research devroom schedule has been organized in thematic panels:

• Academics developing software testimonies panel
• Visual inquiries panel
• Policies panel
• Artificial Intelligence Panel
• Open Hardware Panel
• Standards panel
• Knowledge management communities panel
• Open Data Panel

Despite being nearly 27 years old, Java is still consistently rated in the top three most popular programming languages in use. The reason for this popularity extends beyond the syntax of the language to the power of the Java Virtual Machine (JVM). With its ability to handle internet-scale workloads, the JVM delivers the performance required for mission-critical enterprise applications.

In this session, we’ll explore Java as it is in 2022. JDK 17 is the ninth (yes, ninth) release in four years. As a long-term support (LTS) release, this is one that many users will choose to use in production. We’ll review the significant new features developers will now be able to exploit as they develop their next applications. With JDK 18 just around the corner and longer term projects like Loom likely to be included soon, what does this year hold for Java?

The VIRTIO standard defines I/O devices that are commonly used in virtual machines today. The last version of the standard was released in 2019 and much has changed since then. This presentation covers new devices and features in the upcoming VIRTIO 1.2 standard.

There are 9 new device types: fs, rpmb, iommu, sound, mem, i2c, scmi, gpio, and pmem. We will look at the functionality offered by these devices and their status in Linux.

This presentation is aimed at users of virtualization who may be interested in new virtual devices that are becoming available in Linux, QEMU, etc. It may also be of interest to driver and virtual machine monitor developers who are considering implementing new devices.

This presentation is about the development and trajectory of Heurist (HeuristNetwork.org), a shared, integrated, extensible data infrastructure (model, build, manage, analyse, visualise, share, publish via integrated CMS) for Humanities research capable of handling the needs of many heterogeneous projects on a single standalone service*, with optional integration across multiple servers by a coordinating index (itself based on Heurist).

Humanities data are interesting (both technically and to the public). They are rich in text, images, objects, people and events, heterogeneous, eminently linkable and sparse-matrix. Personal computers, the internet and other accessible technologies have spawned an exploding field (or fad?) known as Digital Humanities (DH), and opened exciting new horizons for research and public engagement.

However, this technological turn has created many problems for a poorly funded research culture with 1-3 year grant funding cycles - choice of appropriate technology, finding and retaining technical staff, initial and ongoing costs, sustainability ... The outcome is often least-effort and inadequate technology (eg. spreadsheets) or ad hoc development, incomplete functionality, maintenance nightmares, data silos and rapid end-of-funding decay; only rich or statutory organisations can maintain a multi-component system for long. Heurist aims to overcome these problems by mutualised Open Source development, schemas stored as editable data rather than fixed structures, demand-driven priority development, and free centralised services and maintenance.

In this presentation I will outline the evolution of our development process, from haphazard experimentation and many costly unused features (2005 - 2009) to a coherent, stable but evolving structure and Extreme Programming (aka living dangerously!), driven by immediate user requirements and incremental daily interface refinement. I will outline some of the fundamental principles we use to maintain backwards compatibility, stability, rapid development and low cost of maintenance for such a complex beast and for so many projects, on a self-funding staff of just 3 FTE. I also hope to attract some technical collaborators, as most of our users are (by design) non-technical.

• We maintain a central index and two free services (based in Australia and France), plus some institution-based servers, currently supporting a couple of hundred research projects in different fields, ranging from doctoral students to networks of researchers.

One feature that sets raku apart from other programming languages is the built-in Grammar parser syntax. This provides a concise, clean and extensible tool for parsing text and triggering Actions according to the content. Navigation aids such as buoys and markers sport flashing lights with characteristics such as color, duration, phase, occulting, speed, height, visibility and so on are represented on navigation charts by way of a short code e.g. Fl(4)15s37m28M.

This talk aims to show how raku provides the average coder (me) with a new practical alternative to Regexs and/or specialist recursive descent modules. It should illustrate how the combination of the raku built-in OO system and Grammars/Actions keeps the problem domain / problem solution in focus via code and visual examples.

In 1982, David Horne wrote a version of chess which managed to fit inside the memory of a 1K ZX81. Although it wasn't a complete implementation, it was impressive enough to be remembered now, almost 40 years later. But running it in 2022 requires at least an emulator, ROM file, and the .P file, which limits the appeal to retro enthusiasts and excludes the intended audience - chess players!

So, I modified the EMF emulator (and the game) to run as an emulator-as-a-service, so that it can be played via the lichess servers with a modern web-friendly interface.

In this talk I'll cover a brief history of the program, how the emulator was modified, how the program was reverse engineered and understood, how this code connects to the lichess server and, most crucially, why someone would do it!

Along the way we'll look at the chess notation, FEN, Z80 assembler, NDJSON, and a few other pieces to show you the complete puzzle fits together.

As was announced in December 2021 https://mariadb.org/new-innovation-release-model/, MariaDB Server now has a new release model, with more frequent major releases. MariaDB Server 10.7 is the first release following this model.

Some of these releases will have 1 year support cycles, while others will be supported long term just like before. In this talk, I will present the pros and cons of this new release model, what it means for the MariaDB Server community, its users and also its developers. This will also give the community a chance to better understand the changes and give us feedback and ultimately ensure MariaDB Server properly serves its purpose of being a true Open Source Database.

Intel SGX provided a mechanism to better isolate user-level software from attackers. However, attackers will still use various methods to attack SGX and user’s Enclaves. And user’s code inside Enclave may also have bugs, which can be leveraged by the attackers. We are from intel SGX SDK team, we have conducted security analysis and pen-test for SGX Enclave (based on SGX SDK) during the past 10+ years. We want to summarize some past exploits we encountered in our daily work and what's the mitigation, hope it can help the Enclave developers to write more secure Enclave code.

Target topics category: TEE-specific attacks and defenses (vulnerabilities, exploits, defensive programming)

Purpose: Explain the Security Properties of Intel® SGX Technology. Help Enclave Developers write more secure code within an enclave. Analyze a sampling of enclave defense-in-depth strategies and protections against known attacks.

SGX Enclave Security and Challenge: Code running within the enclave must be written securely. Poorly written code may be subject to attack by various methods. Developers must also be aware of potential side-channel attacks on code.

The reMarkable 2 is an eInk tablet, based on the i.MX7 SoC. The tablet ships with a fork of the 4.14 kernel and a custom rootFS built with OpenEmbedded. The vendor kernel is based on the NXP vendor kernel with a large collection of rM2 specific patches on top.

This talk discusses the process of adding support for the rM2 to the mainline Linux kernel. The talk first discusses the process of understanding the original boot process and then getting access to a download mechanism and serial console.

Finally the talk covers the process to start upstreaming the patches from a vendor kernel to the mainline kernel.

How we use the Sparse C Abstract Syntax Tree and linearized Intermediate Representation to write custom checks for the Linux Test Project API.

Faster computations, faster communication speeds, faster everything. Today electronics can use data rates of several gigabits per second. At such speed wires and tracks are far from being perfect, bugs and glitches may arise because of them. Even low-speed designs are not safe and can encounter high-speed problems because they use high-speed capable chips.

While the electronic CAD software KiCad has the tools to design high-speed boards, there is no tool to validate them. The usual way is to apply all good practice rules, even if they are sometimes overly conservative and might waste some board space. The layout plays an important part in both PCB performance and cost. A PCB simulator, integrated into KiCad, would help designers to find their balance between the two. This presentation is a short introduction to IBIS and FEM, tools that will most certainly be needed for such high-speed simulations, and provides application examples.

A design system helps contributors create consistent user experiences. To elevate from a collection of patterns to a system, you need to provide clear standards and reasoning. Clear and comprehensive documentation helps you put this system together into something everyone can use.

This talk will go through how we open sourced the documentation for the Orbit design system and discuss what we learned from the process. It will discuss creating both visual and content standards for the docs and how it was all accomplished. The lessons from this experience can help in the creation of useful and accessible documentation to guide the design process.

Developed from 1995 onward, Prospero is a framework for longitudinal analysis of text corpora. Based on dictionaries and semi-automatic classification, it mainly allows its user to combine approaches of statistical computation, co-occurrence network and search for nested patterns. Inspired by pragmatic sociology, it focuses on the multiple forms of expression and argumentation used by actors, on language regimes and on the identification of transformations occurring in the research case. Initially distributed commercially, then from 2011, by the Doxa association, as shareware under a non-profit and ethical charter, it is now hosted by the Corpora association and developed under the aGPLV3 CECILL variant Affero compliant license.

In this presentation, we will discuss more specifically the question of the permanence of a research-targeted software approach, through its evolution over almost 30 years. During this period, evolving expectations and technical developments have led to a client/server step (which remained in the prototype stage) and now to the transition to SaaS. Based on this experience, we will also discuss the conditions we consider relevant for the durability of the software in a new interconnected phase. The broadening of its audience of users and developers calls for ever greater interoperability, on the technical level, but with an approach that combines non-profit and academic models (with limited resources) and business uses.

Josquin Debaz With a PhD in history of science, he has worked more than 10 years on contemporary controversies in health, environment and energy at GSPR (Pragmatic and Reflexive Sociology Group, EHESS). He is now developer at Finsit. With F. Chateauraynaud, he published Aux bords de l'irréversible. Sociologie pragmatique des transformations (Paris, Pétra, 2017).

Waldir Lisboa Rocha With a degree in Environmental Engineering, he co-founded Luminae, an energy efficiency company, where he served as Chief Operating Officer between 2008 and 2012, before deciding to make a turn in his career and dedicate himself to the Social Sciences. He holds a Master's degree in Sociology from the École des Hautes Études en Sciences Sociales - EHESS, and is currently working on his PhD at the same institution, in which he is focusing on the relations between media, inquiry and democracy. In parallel to his academic research, he has been dedicated to the conception and structuring of Prefigura, an experimental institution, and of Enumera, an operating ecosystem.

MariaDB is one of the most used open-source relational databases. The development of MariaDB focuses on stability and performance.MariaDB 10.6 is the current stable version of MariaDB and comes with a number of new features. This presentation covers - MariaDB in Open Source Ecosystem, Features in MariaDB 10.6, Variables added and Removed.

CodeReady Containers runs an OpenShift cluster on a laptop or workstation using virtualization. It's written in go, and uses KVM, HyperV or HyperKit depending on the OS it's running on. External network access is done through gVisor's userland TCP/IP stack which the virtual machine uses over virtio-vsock.

This talk will start with a short presentation of what CodeReady Containers is, explain why it needs a userland TCP/IP stack, but its main focus will be around virtio vsock, how to use it from go, and the differences to expect on the different hypervisors.

In this presentation Sebastian shares project experience gained over nearly 2 years of the Oniro project development in the area of product research & development. He starts with the initial assumptions and various criteria that team members intended to apply to the work done. It was a very interesting experience to apply a product-driven approach to highly-paced open-source projects nowadays. Thus, the great effort was put in order to receive maximum value from products intended to deliver to the market. Ettore is an Embedded Linux Developer, and joins to share the partner experience as he is part of the Hardware Enablement Team for SECO.

In this talk, Sebastian is going to present a few product management principles, how they were applied to the project and what lessons were learnt in this process. The talk is filled with a few open source projects (e.g. GitLab, OpenProject and others) and how they were applied to the tasks we were faced with. Work package structures and workflows applied were also described to supplement the presentation. To conclude, Ettore joins the talk as representative of one of the Oniro Project partners, SECO, describing how was the experience in the last year, as an Internet of Things Hardware manufacturer.

If you are building an open source community or are aiming to build one, this talk might be an interesting option for you.

Gramine (formerly called "Graphene") is a lightweight library OS, designed to run a single Linux application in an isolated environment. Currently, Gramine runs on Linux and Intel SGX enclaves on Linux platforms. With Intel SGX support, Gramine can secure a critical application in a hardware-encrypted memory region and protect the application from a malicious system stack with minimal porting effort ("lift and shift" approach).

Several major events happened to the Gramine project in 2021. Gramine changed its name, moved to a new GitHub repository, and joined Confidential Computing Consortium. The first production-ready release of Gramine -- v1.0 -- was published in October 2021. This talk will discuss all these events, as well as the current status of the project and its future plans.

In this talk, I will present Arcon, a Rust-native streaming runtime that integrates seamlessly with the Apache Arrow ecosystem. The Arcon philosophy is streaming first, similarly to systems such as Apache Flink and Timely Dataflow. However, unlike all existing systems, Arcon features great flexibility when it comes to its application state. Arcon's TSS query language allows extracting and operating on state snapshots consistently based on application-time constraints and interfacing with other systems for batch and warehouse analytics.

The 'serial port,' usually carrying RS-232, has once been the window to the world on capable systems. This talk is a brief history on it, its use cases and its current state. Is it still relevant? Do we still love it? Are there alternatives?

I am a social scientist who mostly teaches and conducts qualitative research, but I am also a programmer. Over the years, I have contributed to a variety of free and open source software projects, and since 2019, I have developed and maintained textnets, a Python package for text analysis that represents collections of texts as networks of documents and words, providing novel possibilities for the visualization and analysis of texts. In my field, such software development efforts are not usually rewarded, but I have been very fortunate. My academic superiors have been supportive of my endeavors, and a publication in the Journal of Open Source Software also helped me get official recognition for this work in the standard currency of my field.

While I developed textnets to scratch my own itch, I seek to make the package widely available by providing extensive documentation and making it easily installable across multiple platforms. This part of my software development work -- learning the intricacies of version control, package managers, continuous integration testing, and dependency management -- puts me in a position to learn not just about the technical side of coding, but about the social side of the choices developers make. At least in the Python world, the way you learn about what dependencies to use, if any, and how many, is informed by norms more than by technical considerations, and the same is true for much else. By engaging in software development work, I engage in a version of the research method of participant observation -- learning by taking part -- that sociologists have called observant participation -- becoming part of what you want to learn about. In my case, I want to learn not just about software development and its culture and norms, but the wider world of free software, hacker culture, artistic practice based on FOSS tools, and more.

In my talk, I provide some background to the development of textnets, give a brief demonstration of the package's features, and finally reflect on my experiences engaging in observant participation as well as some of the insights I have gained and still hope to gain.

By now, we all know that JDK 17 is the latest Java long-term supported release with several new language features. There are already many resources that explain the Java Record and Text Blocks in detail. But JDK 17 has much more interesting changes since JDK 11.

In this session, I go into more detail about some other interesting changes that are not language features but are a good reason to switch to JDK 17.

• Improvements in the Class Data Sharing feature.
• JDK Flight Recorder for monitoring purposes.
• Improvements in Performances in the Garbage collectors
• Preventing security issues with context-specific deserialization filters.

Besides the explanation, you also see these changes in action with some demos.

Welcome talk and introduction to the Microkernel and Component-based OS devroom at FOSDEM 2022.

At the time of writing, MariaDB 10.7 is in RC, and the MariaDB 10.8 preview releases are imminent. The new release model means new features no longer have to wait a year between major releases before seeing the light of day, and the initiative of separate preview releases for each major feature eases testing and reduces instability.

This presentation covers some of the major new features being unveiled in MariaDB 10.7 and 10.8.

Writing Free Software is very different from writing proprietary software for a huge software company like Google or Facebook – the team size, incentives, and likelihood of turnover are all completely different – and, as a result, the ideal languages are very different as well. Or at least, this was the thesis for my 2021 FOSDEM talk "Imagining the Ideal Language for Writing Free Software".

Over the past year, however, I've concluded that this argument – while correct any many areas – does not apply to dependency management. When it comes to dependency management, writing Free Software isn't on the opposite end of the spectrum from writing code for Google — it's on the same end, but even further along. This talk will elaborate on what I mean by that statement and discuss the implication I believe that this has for Raku.

Concurrent code is hard to get right, but at the same time also hard to test. It gets worse when hardware interaction is required. This leads to a comparatively poor culture of unit testing in kernel code, where both come together.

In this talk, I’m going to highlight one particular method of unit testing the page table manipulation code in Hedron, a microkernel written in C++ specially geared towards virtualization workloads. This code safely modifies page tables that are concurrently used by the CPU. Usually, unit tests only check whether the state after an operation meets the expectation of the programmer. In contrast, Hedron employs completely deterministic unit tests that show that the CPU will always see a valid virtual memory mappings while a page table manipulation is in progress (for the tested cases).

The goal of this task is to show that unit tests can be a powerful tool even for properties of code that are usually not deemed unit testable.

Nemomobile is operating system for mobile devices based on Manjaro Linux and Glacier UI. It mainly developed on PinePhone, but it could be runned also on android devices. The talk will summarize its current status and its direction in future.

The Enarx project reached a huge milestone: its first official release, featuring WebAssembly runtime. WebAssembly and Confidential Computing are a great match because WebAssembly offers developers a wide range of language choices, it works across silicon architectures, and it provides a sandboxed environment. This presentation will highlight the benefits of WebAssembly to Confidential Computing and showcase some demos.

After 3 years since its inception, the Enarx project finally had its first official release, bringing WebAssembly to Confidential Computing.

Enarx is a deployment framework for running applications in TEE instances – which we refer to as “Keeps” – without the need to trust lots of dependencies, without the need to rewrite the application, and without the need to implement attestation separately.

The WebAssembly runtime, based on wasmtime, offers developers a wide range of language choices for implementation, including Rust, C, and C++. It is designed to work across silicon architectures transparently to the user so that the application can run equally simple on Intel platforms (SGX or the recently-announced TDX), AMD platforms (SEV) or forthcoming platforms such as Arms’ Realms and IBM’s PEF - all without having to recompile the application code. WebAssembly's sandbox model offers an extra layer of protection, isolating the application from the host.

As one of the earliest large FLOSS projects, Mozilla had a strong and growing community of volunteer contributors for a long time. Then, a lot of factors leading up to today led to the environment changing very significantly, and today's community has some good groups in some areas, but not the kind of connected movement that existed in those earlier times. The speaker has been part of all of that development, starting off as a volunteer very early in the project, working on Mozilla staff for a few years in between, and still being part of the volunteer community in recent years. From that point of view, he'll bring up some ideas and suggestions on how this community can become stronger and grow again, so that a significant voice for the Open Web and the Mozilla Manifesto will hopefully be out there also in the future.

As research becomes more globalised and its output grows exponentially, especially in data, the need for open scientific research practices is more evident — the future of modern science. There is now a concerted global interest in open science uptake, but barriers exist. The formal training curriculum in most, if not all, universities in the global South do not equip students with the knowledge and tools to practice open science in their research or develop open-source tools. To work openly, collaboratively, and build a community, there is a need for awareness and training in using and developing open science tools. Through the OpenScienceKE framework, we developed a model to narrow the gap: the sensitize-train-hack-collaborate model. Using the model, we sensitised through seminars, trained on the use of tools through workshops, applied the skills learned in training through hackathons to develop open-source tools collaboratively. In this talk, I will demonstrate the need to Contextualize open source to ensure that no one is left behind, especially the Global South, and highlight some of our work in building an empowered community.

Any conversation about Big Data would be incomplete without talking about Apache Kafka and Apache Flink: the winning open source combination for high-volume streaming data pipelines.

In this talk we'll explore how moving from long running batches to streaming data changes the game completely. We'll show how to build a streaming data pipeline, starting with Apache Kafka for storing and transmitting high throughput and low latency messages. Then we'll add Apache Flink, a distributed stateful compute engine, to create complex streaming transformations using familiar SQL statements.

This session is aimed at data professionals, who are ready to embrace open source streaming and make their data fly.

Immutability is a powerful concept. Without it we wouldn’t be able to rely on bank transactions, medical records or even some of our private data. And we usually take for granted that our data is safe somewhere out there in the "cloud". But is it? There are well-known multi-billion dollar stories where attackers were able to break into well-secured systems and modify data stored in databases.

What if there was a way to protect the immutability with math? What if any attempt of historical data manipulation could easily be detected? In this talk I’ll share how we do it in immudb - a new database built on a zero-trust model.

Warm welome to the Open Source Firmware, BMC and Bootloader devroom.

What is new in WebRTC, what can we expect to see in the next couple of years? I'll describe some new APIs and speculate on how they might be used. I'll introduce whipi (an opensource implementation of the new WebRTC Ingest Protocol) and use it to illustrate how the WebRTC world is changing. I'll try to predict some new usages of WebRTC - niche high value apps. Finally I'll describe how to create a decentralized web (aka web 2.5) using the datachannel and existing browser technology.

We've all spent a lot of time using centralized video conference services in the last months. We have got a huge amount done at home whilst behind NAT on domestic ISP connections. This has all been possible due to webRTC's design.

This talk tries to look beyond that usecase to new less business orientated realtime media and data apps that are enabled by new(ish) APIs.

For economic,privacy and ecological reasons I'll emphasize apps that move computing to the edge. It will cover Baby monitors, robots, yoga classes and P2P web services and other surprising stuff...

With the Foreman Project dropping support for EL7 in Foreman 3.3 (~Summer 2022), it's finally time to tackle that migration to EL8 you have been putting off for a while now. In this session we will present various ways how you can migrate your installation from EL7 to EL8, with the main focus on the in-place upgrade using LEAPP/ELevate.

The Foreman Project is planning to drop support for EL7-based deployments in Foreman 3.3, mostly due to the fact that EL7 is considered "feature complete" and there are no further updates (besides security fixes) planned for it. Contrary to Debian or Fedora, EL-based distributions aren't designed to be upgraded in-place without special tooling. This tooling exists in form of the LEAPP project for RHEL and the ELevate fork by AlmaLinux for AlmaLinux, CentOS, Rocky Linux, and Oracle Linux. We have developed a plugin for LEAPP that helps with the Foreman-specific parts of the migration, which we would like to present to you. As usual, there were a few challenges during the development, which will hopefully entertain you and maybe even help if you need to write own LEAPP plugins. And last but not least, we will also discuss other approaches you can take for the migration, if you do not want to upgrade in-place.

OKD Virtualization is the community project bringing traditional virtualization technology into OKD. Meet the OKD Virtualization community and learn about it!

OKD Virtualization is the community project bringing traditional virtualization technology into OKD. It’s built on top of the KubeVirt project and the Hyperconverged Cluster Operator project. HCO ensures a single installable unit for Kubevirt and its sibling components leveraging the operator framework to provide the easiest way of installing and maintaining this additional control plane. This bundle will ship additional tools required to do traditional virtualization tasks like uploading disk images, host network configuration, local storage provisioning, and other functionality which is not covered by the core KubeVirt. On top of this a user interface embedded within the OKD Console is provided for managing the lifecycle of the Virtual Machines. Virtual Machines from other virtualization systems can be imported into OKD Virtualization leveraging the Konveyor Forklift project. Meet the OKD Virtualization community and learn about it!

After this session you will Know what KubeVirt is Know what HCO (Hyper Converged Cluster Operator) is and how it relates to KubeVirt How the OKD UI is presenting VMs A rough idea of the featureset of what this setup provides Seen a demo, and knowledge of how to set this up yourself

This will be joint presentation between realthunder and officinerobotica. The talk will first give a brief introduction of FreeCAD and its Link Branch, and then proceed to talk about its development in the past year with reference to the talk in FOSDEM21. New features will be presented by walking through the construction of a CAD model using FreeCAD. The talk will finish by highlighting new features in development and the road map ahead.

Discussion panel of three testimonies from academics developing software.

Developing software from academia is not easy. Scholars are meant to teach and write. Releasing a research software demands much more than writing code. In this panel discussion, the four speakers will share their thoughts on those challenges. The discussion will benefit from the variety of situations they all bring : a "scholar-analyst" collaborating with a tech team, a team of scholars/engineers and a sociologist who codes alone. Should scholars leave coding to the professional? What does open sourcing code brings to the game? What does maintaining a research software require? Is coding from academia actually fun or a burden?

Add your own questions to this list by participating to the live event. Questions from the audience (chatroom) will be asked to the panel by the moderator.

We will look at the Year 2021, check out what has worked out what did not work out. We will look at the most imortant things that we need for 2022. And we will talk about things around the Project

The import and export of common office formats (.ods/.xlsx, .odt/.docx, .odp/.ppt) is taken for granted in many online office suites. However, in the case of CryptPad, implementing such functionality presents a number of challenges to preserve our privacy requirements. This has long held back adoption of our platform as it prevented users from migrating existing documents and/or integrating CryptPad in their workflows.

In this talk I will summarize our work on INTEROFFICE, a project realized by the CryptPad team in 2021 with funding from the EU's Next Generation Internet (NGI) DAPSI program. The core of this work consists of a new set of converters that use Web Assembly to perform conversions between file formats in the browser. This allows for CryptPad to be vastly more inter-operable while preserving end-to-end encryption (the server still has no access to the content being converted).

Speaking as the designer on the team, I will focus on the research we conducted with users and on the ways this new functionality is making its way into CryptPad's interface.

Among many challanges around initializing hardware, security, and booting into operating systems, firmware also needs to provide an interface for the user to change settings, set up a trust anchor, or simply enjoy colorful graphics. This talk summarizes approaches from (U)EFI dating back to 2003, looking at modern OEM UIs in comparison to open implementations such as the menu in webboot, those from System76, EDK2, and Dasharo, and showcasing prototyping environments for further development, finishing with a short discussion of reusable and portable abstractions for designing APIs.

Current MariaDB Server GA versions are formally not supported on macOS 10.x and 11.y. But it;s relatively easy to set up the environment and build it from current 10.2 - 10.7 GitHub sources, with few minor issues to resolve in the process depending on maxOS and major server version used. This talk is a summary of my related experience, with a quick review of related fixed and open bugs, as well as some unique features like DTrace support that one may benefit from on macOS.

Current MariaDB Server GA versions are formally not supported (and probably not even regularly built or tested) on macOS 10.x and 11.y. But it's relatively easy to set up the environment and build MariaDB Server from current 10.2 - 10.7 GitHub sources, with few minor issues to resolve in the process, depending on maxOS and major server version used.

This talk is a summary of my related experience on 10.13 High Sierra that I had a chance to work on recently, with additional quick review of related fixed and open bugs, as well as some unique features like DTrace support that one may benefit from on macOS. Actually, studying DTrace in context of MariaDB Server troubleshooting and performance tuning was one of the goals why I started to use macOS again.

Operating system of Apple-1 written by Steve Wozniak is an engineering piece of art – 256 bytes only! We will explain how it works using the original 6502 assembler source code along with our own rewritten in Python version so every software engineer could understand how It works. It should be useful for engineers who want to know basics of operating systems.

We will cover: – what are the functions of the simplest operating system – what functions of operating system are hardware-specific – how it communicates with the user – how it runs the programs

GNU/Hurd is the original Free Software operating system started in the 1980s. Its microkernel design has been evolving over the years and the project has not quite hit mainstream use. I believe this is due to one main reason: the lack of drivers for peripherals and hardware. In this talk, I explain how NetBSD kernel drivers have been reused in a microkernel setting and demonstrate their use to boot up a GNU/Hurd system via a userspace rump disk driver, with a driverless Hurd kernel, gnumach. The ACPI management, PCI management, and actual driver are in separate processes with RPC interfaces between them, which separates out their debugging, licencing concerns and execution. I believe this aligns with the original vision for the operating system, (as a Hurd of servers).

The technical presentation is about how to use mocks to unit test Linux kernel drivers. The presentation explains how mocks help validating operational code. For instance by checking parameters passed to mocked function, or by configuring the mock to return an error code.

The presentation will include some unit test examples that use a mocking tool which is called EasyMock. I'm the author of EasyMock.

The writing of web publications mixing data visualization and textual prose opens novel opportunities for connecting evidence, arguments and narrative in social sciences communities. Such a practice poses a variety of challenges in terms of website design and development ; but also and maybe more importantly, it asks for experimenting specific workflows for coordinating a variety of expertises ranging from social sciences disciplines (history, sociology, etc.) to data science, information design and web-related skills. It also reconfigures, for the research processes themselves, the relationships between activities of (data-related) enquiry and (communication-oriented) writing, creating a renewed space for discovery, invention and verification for the data sustaining a given argument or narrative.

Relying on recent experiments in making collective digital publications grounded in sociology of technology (https://medialab.github.io/carnet-algopresse/#/publication/en) and history of economy (https://medialab.github.io/portic-storymaps-2021/), this talk accounts for the diverse challenges arising from such activities of “data visualization-driven writing”, and some strategies we used to cope with them. It describes and compares the technical and methodological workflows we developed in order to simultaneously develop text, datasets and visualizations, taking into account a variety of aims, data materials, and distribution of skills. Doing so, it advocates for an extended understanding of the notion of “academic writing”, encompassing the practices of writing software, data and diagrams. Such an extended understanding, we argue, is necessary to design and develop writing workflows allowing to foster a multimodal and scientifically productive dialogue between these heterogeneous practices, taking full advantage of the web publication format as a research situation.

A little guide on how to convince management to try out new technologies!

For you it's obvious, Kotlin is the next big thing and it'll bring your team to the next level. You see clear advantages, but others are not quite there yet. In this talk, I'll describe the ways we found to get Kotlin inside ING, one of the largest European bank. We'll look into simple ways to convince your colleagues, your management and make it a success for everyone!

Those days, there are so many tools to improve one developer's workflow that it's hard to make a choice, and sometimes convince others. Languages, frameworks, tooling, paradigms, there is so much to try and not everything can be a benefit.

In this talk, we will have a look at why Kotlin probably makes a lot of sense for your team. We'll have a quick glance at some language features, the ecosystem and the community as well.

But we'll mostly have a look at various techniques to make Kotlin (or for that matter, any other kind of proposal) a convincing user case for your team. Finding your heroes, making small experiments, using external influence, building in public, defusing possible worries, there are many ways to go about it!

By the end of this talk, you will have extra information on why Kotlin can be useful for you (or not); and be equipped with strategies to help convince others as well.

Short break.

Tracim is a web-based collaboration software mainly written by the Algoo company. Main specificities are well-integrated functionalities and intuitive UX. It aims to be easy to use for any kind of people wanting to work in teams.

During this talk, I will tell you about Tracim architecture. You will discover the components and the reasons behind major design choices. Then I will detail more specifically a technical feature which brings Tracim users an interactive experience when collaborating with others.

Common Voice is a project to help make voice recognition open and accessible to everyone. To create this data set Common Voice allows volunteers to record defined sentences to contribute their voice. A good data set needs a lot of recordings, and therefore we need to have a lot of sentences to be read out aloud. In this talk Michael will introduce the audience to several ways we are collecting these sentences and goes into more technical detail for these mechanisms. This talk will also feature an intro to Common Voice at the beginning.

This talk presents ToroV, a novel open-source technology that combines virtualization and containerization to enable the execution of users’ applications in a safer and improved manner. In ToroV, applications run as Virtual Machines without the need of an OS, unikernel nor device-model. ToroV combines a minimalist Virtual Machine Monitor and a virtualized guest program communicating through POSIX APIs. When the guest application requires to open or write a file, it just invokes the VMM using hypercalls. The VMM intercepts those hypercalls, processes the request, and returns to the guest. The sysadmin defines the ACL (Access Control List) of authorized hypercall per virtualized guest application. This allows the user to control the host’s surface that is exposed to the guest. In this talk, we propose to present the ToroV architecture together with several ongoing experiments. For example, the minimalist VMM allows us to boot up a VM in KVM in less than 6 ms. Also, we show how we debug guest applications by simply using GDB and the KVM API for debugging. During the talk, we discuss the main differences with unikernels and containers and how ToroV gets the best of both worlds. Also, we present the main differences with gVisor, which is a similar project from Google.

In this presentation we discuss the Conversational Agent (CA) designs for two closely related problem areas:

• Data Acquisition Workflows (DAWs)

• Data Transformation Workflows (DTWs)

The CA perspective is taken mostly for exposition and didactic purposes. Nevertheless, we emphasise the practical applicability of the underlying designs and implementations.

Although, operationally data acquisitions are prerequisite for data wrangling we discuss data wrangling first -- the corresponding DTWs designs and implementations are more mature and the related materials are more universal, applicable to multiple programming languages.

Multi-language Data Wrangling and Acquisition Conversational Agents

Anton Antonov
FOSDEM 2022

Abstract

In this presentation we discuss the Conversational Agent (CA) designs for two closely related problem areas:

• Data Acquisition Workflows (DAWs)

• Data Transformation Workflows (DTWs)

The CA perspective is taken mostly for exposition and didactic purposes. Nevertheless, we emphasise the practical applicability of the underlying designs and implementations.

Although, operationally data acquisitions are prerequisite for data wrangling we discuss data wrangling first -- the corresponding DTWs designs and implementations are more mature and the related materials are more universal, applicable to multiple programming languages.

Outline

Data Wrangling

In the first part of the presentation we show and compare data wrangling examples in different programming languages using different packages.

Here is a list of the programming languages and packages we consider:

• Julia-DataFrames

• Python-pandas

• R

• R-tidyverse

• WL

We look into the common data wrangling workflows and how we can design a conversational agent that translates natural language commands into data wrangling code for Julia, Python, R, SQL, WL.

WL's external evaluator features are heavily utilized.

Data Acquisition Workflows

In the second part of the presentation we discuss the following facets of a data acquisition system:

• Conversational Agent based on a Finite State Machine

• Gathering and utilizing metadata taxonomies

• The making of datasets recommender systems and search engines

  • In/for both R and WL

• Making (ingredient) variables queries

• Introspection queries

• Random data generation specifications

• Data obfuscation specifications

Extensions to ML models acquisition workflows

MariaDB 10.8 is getting improved histograms, called JSON_HB. This talk will cover - what the new histograms are, - what are the advantages over the old histograms, - how do they compare to histograms in MySQL 8.

At the end of the talk, I'll cover a closely related topic of usage of the histogram data in the query optimizer: - why this is hard, - what are known limitations and their workarounds - what MariaDB team is doing to improve this.

Veracruz is a framework for designing and deploying privacy-preserving computations amongst a group of mutually mistrusting individuals. Veracruz uses strong isolation technologies, such as AWS Nitro Enclaves, Arm CCA Realms, and the high-assurance seL4 hypervisor, to provide a safe, neutral ground, within which a sandboxed WebAssembly program executes. Recent enhancements to Veracruz have made it possible to support larger, more complex privacy-preserving computations: we have adopted the WebAssembly System Interface (WASI) as our programming model, which can be used by executing WebAssembly programs to query and modify an efficient in-memory filesystem, for example. In this talk, I will first introduce Veracruz before finally focusing on a real-world use-case for Veracruz, in privacy-preserving video object detection, developed as part of a collaboration between the Veracruz team and IOTEX, a manufacturer of IoT cameras.

This talk will show a new Python tool called Livemark, which is designed for data journalism software education, and documentation writing. Using Livemark, you can collect and present data with interactive tables, charts, and other elements without leaving a text editor. You can also write documentation with live script execution similar to a lightweight version of a Jupiter Notebook. This talk will demo Livemark and will be well-suited for a technical and non-technical audience that is interested in learning about data storytelling.

No prior knowledge is required although a basic knowledge of Markdown and Python scripting will help understand in-depth sections.

The current Linux packaging used by Apache OpenOffice is inefficient in many ways. We can take advantage of technologies like AppImage, snap and flatpak in order to make OpenOffice easier to install for Linux desktop users, while saving disk space for releases at the same time.

Introduction and welcome to the dev room

I work with Purism SPC on the Librem 5 phone kernel. I regularly post what our team pushes upstream into the mainline kernel at https://puri.sm/posts/author/martin/

In this little talk I want to summarize what we've done, describe how we do it and put it into perspective a bit.

I'll outline rough future plans and of course encourage to participate in case you own that phone.

Nowadays everyone can run an event (meetup, hackathon, etc), but sometimes we struggle in selecting the right tool to organize it in an effective way. What tools are out there that can help us run any type of event and have impact?. We will do an overview about options, limitations and resources you will need to make a great event.

If you are lost trying to choose the right tool for your first online event, this talk is for you. And if you think you know everything about tools and ways to engage with your audience, you will be welcomed as well, since we will discuss about these things and more.

Nowadays everyone can run an event (meetup, hackathon, etc), but sometimes we struggle in selecting the right tool to organize it in an effective way. What tools are out there that can help us run any type of event and have impact?. We will do an overview about options, limitations and resources you will need to make a great event.

If you are lost trying to choose the right tool for your first online event, this talk is for you. And if you think you know everything about tools and ways to engage with your audience, you will be welcomed as well, since we will discuss about these things and more.

Driven by the vision of a truly trustworthy smartphone, I dedicated the past year to bringing the component-based Genode OS to the Pinephone. The talk presents my experience story, touching on the hardware, booting, the porting of the kernel, component-architecture concerns, and device drivers.

Smartphones have become a commodity almost everyone relies on. With the convenience, however, comes complexity that is impossible to comprehend and constantly changing. The opaqueness of hardware and software puts the user in a subordinate position, making their devices - and by extension many aspects of their life - dependent on the decisions of a few dominant corporations. Our personal devices are constantly changing under our fingertips. Steady updates are presumably needed to stay secure, similar to how medicine is needed to stay healthy. But are the incentives of the platform providers aligned with my interests?

I want my digital life healthy without a constant supply of medicine! To reinforce trust, both hardware and software must become transparent, traceable, and tractable. The Pinephone satisfies the urge for transparency of the hardware, thanks to publicly available schematics and documentation. However, the predominant software stacks - even though based on the open-source Linux kernel - are practically inscrutable because of their immense complexity. Genode's rigid component architecture promises to bring order and clarity - and thereby trustworthiness - to the software.

Over the course of the past year, I pursued the combination of Genode with the Pinephone, diving deep into the Pinephone schematics, the SoC, booting, Genode's kernel, and device drivers. In my talk, I present the experiences made, touch on the use of Linux drivers directly on Genode, and draft a plan forward. The talk will be garnished by a demonstration.

Java 17 finally gave us the first incubator of Foreign Function & Memory API. Let's do a test drive of what is in store and see if it is good enough to replace JNI. Let's be honest, JNI is not that secure and is controversial and it's high time we move away from it and adopt FFI like in many other modern languages. But is the new API enough or do we need to consider external libraries like JNA or JNR-FFI? I'll showcase some examples of using the new API with some of my other favorite languages.

BabiaXR is a set of FOSS modules for VR (virtual reality) data visualization for the browser. BabiaXR is based on A-Frame and Threejs, with the goal of making it very easy to create different kinds of data visualizations (bar charts, bubble charts, cities, ...), by exploiting the power of WebVR and regular web front-end programming. In this talk, I will do an overview of BabiaXR, showing different examples of different common visualizations. Then, I will focus on showing how we use the city metaphor to represent a popular FOSS project, showing its evolution over time. The talk will show examples (in VR) that the public can try on the fly.

There are plenty of tools that can analyze data in many ways, but just a few of them try to visualize this data beyond 2D. This is the goal of BabiaXR, a set of front-end modules for 3D VR (virtual reality) data visualization. The visualization part of BabiaXR is based on A-Frame and Threejs, providing a collection of components for creating different kinds of visualizations. Among them there are common ones like bar charts, pie charts, bubbles chart, but now we are moving beyond that, exploring new ways of showing data in 3D. For example, we are working on representing software projects using the city metaphor, showing the evolution of the project as the evolution of a city, with building corresponding to the different files. In this talk, I will do an overview of BabiaXR, showing different examples of the power of WebVR and A-Frame with different visualizations. Then, I will analyze a city corresponding to a well-known FOSS project, showing its evolution in different time snapshots and explaining how the code evolves as the city does. Moreover, there will be examples that the public of the room can try on the fly in their devices, and I will bring a set of two different VR devices to show the examples in an immersive environment after the talk.

As A-Frame was developed in part by Mozilla developers, and it is used in some Mozilla services (such as Hubs), I think that it is interesting to show what kind of things, beyond games, can be done with this awesome framework, specifically, related to data analysis and new different ways of data visualization, like the cities that you can build with BabiaXR.

The persistent circular buffer (the ib_logfile0) is the fundament of the persistent InnoDB buffer pool.

Over the years, the log file format has been changed in MariaDB Server to improve the performance. A well-designed file format imposes minimal write amplification and is easy to parse.

The 512-byte block size of the InnoDB log was a perfect match for the industry standard that was defined by the venerable Seagate ST-225. Alas, the industry moved on, and now block sizes range from 64 bytes (the size of a memory cache line) to 4096 bytes. Therefore, a format that works efficiently with any block size is needed.

We present a flexible format where each mini-transaction (comprising log records) is a block on its own, with a checksum that is calculated in a local buffer, reducing contention on the mutex that protects the global log buffer. The old 12-byte block header is shrunk to a 1-bit sequence number, for detecting the end of the circular log. The additional overhead is 4 bytes per mini-transaction for a CRC-32C checksum.

No-op records may be written to pad the log buffer to match the physical block size. Encryption will only cover data. The length of each record is explicitly stored in clear, which allows consistent hot backups without having any encryption keys. For encrypted log, 8-byte part of initialization vector will be written after each mini-transaction.

A short overview about the progress and the current state of the LibrePCB project.

LibrePCB is an Open-Source EDA software to design PCBs, providing the following advantages:

• Cross-platform: Windows/Linux/MacOS/Others | x86/ARM
• Intuitive & easy-to-use UI
• Powerful library concept
• Human readable file format

We will try to define in this presentation basic user needs for a generic working environment on historical data, discuss then some key technologies and architecture orientations for online open-source application MetaindeX, which intends to fulfill those user requirements. At last, we will illustrate its usage with a real corpus of few thousands French archives from "Archives Nationales", from 16th and 17th century.

This presentation intends to illustrate how MetaindeX opensource application could match a significant part of user needs, especially in the fields of history and humanities. It first defines an overview of what user requirements could be for a working environment offering a ready-to-use, coding-free, quick and efficient access to advanced exploration, analytics and graphs capabilities over an historical data corpus for the researcher. It supposes that input data has already been collected, cleaned and reconciled, focusing on the exploration and analytics parts of researcher workflow. In a second part, it then develops those needs through key technologies and architecture choices made for design and development of online open-source application MetaindeX [1]. At last, a sample use-case illustrates user experience and shows some analytics results from the use of MetaindeX and its ecosystem (Kibana and Gephi mainly), based on a set of French archives from 16th and 17th century.

With redpesk, we provide customers the ability to cross-build an embedded, CentOS Stream-based Linux distribution in the cloud. This requires a significant infrastructure: Koji/RPM builders, Angular-based WebUI, Gitlab forge, network and RPM package dependency management, Qemu test lab management, all need to come together and be connected, in a mix of Qemu virtual machines and LXC containers. Fortunately, Ansible and Proxmox comes to the rescue to manage this complexity.

In this talk, we'll present our architecture of a self-contained CI/CD environment in the cloud, to cross-build RPM packages and Linux images. We will then dive into the specifics of using Ansible to drive Proxmox and deploy a mix of Packer-built Qemu virtual machines and LXC containers. Those provide a full Koji build system (hub and builders), an Angular frontend, Go backend, a Gitlab forge as well as network isolation/firewalling and a Qemu virtual target lab. We'll continue with lessons learned from doing these deployments for multiple customers. We will finish describing solutions we are currently working on, like Ansible AWX, to address the challenges of doing it at scale and increase automation.

The broadcasting industry has for years been dominated by a specific set of technologies (RTMP, HLS, etc.) that, while effective, suffer from high latencies and so are not always a good option. The IETF has started to look into WebRTC for that, starting from ingestion using the WHIP protocol. This presentation will introduce WHIP, some existing implementations, and how this could be expanded to distribute streams to a wide audience via WebRTC as well.

The broadcasting industry has for years been dominated by a well known and specific set of technologies (RTMP, HLS, etc.). These solutions do work and are widely deployed, taking advantage of CDNs for distributing streams to a potentially very large audience in an effective way. That said, they do suffer from some limitations, the stronger one being a high latency that cannot really be reduced, if not slightly. Considering there are scenarios where a very low latency may be desired, WebRTC has started to gain some traction, due to its real-time nature that, although originally conceived for conversational scenarios, has actually often used for streaming purposes as well.

When it comes to broadcasting, there are two main aspects to take into account: ingestion (providing a stream to broadcast) and distribution (feeding the stream to an audience). The IETF has started addressing ingestion in the WISH Working Group, with a draft describing the WHIP protocol. This presentation will introduce what WHIP is, its requirements, and how it's supposed to work, plus some details on existing implementations. It will then move to some considerations on how distribution could be handled via WebRTC as well, possibly at scale, using the open source Janus WebRTC Server as a reference implementation.

As the number of VMs per node gets larger, using more powerful nodes (i.e. with more CPUs and RAM), the scalability of Kubevirt's control plane becomes a bottleneck, slowing down the VMI creation process. This talk will cover the motivations and concepts around general benchmarking of the KubeVirt control plane, as well as explaining the journey to running a density test with hundreds of VMs per node.

Kubevirt's performance and scalability are determined by several factors. As the number of VMs per node gets larger, using more powerful nodes (i.e. with more CPUs and RAM), the scalability of Kubevirt's control plane becomes a bottleneck, slowing down the VMI creation process. This talk will cover the motivations and concepts around general benchmarking of the KubeVirt control plane, as well as explaining the journey to running a density test with hundreds of VMs per node. In addition, I'll provide some performance metrics comparing VM build time in various scenarios. Participants will have a high-level knowledge of the on-going KubeVirt's sig-scale community performance assessment and the single-node scalability characteristics of KubeVirt.

The HomeComputerMuseum is founded in 2018 after its initial plan in 2016. The idea of an interactive computer museum while being a social company and fully independent of subsidy. In 2020, right after a move to a bigger and more permanent location, the unsubsidized museum had to deal with corona. Against all odds, the museum survived and even grew faster than ever before, becoming world's largest museum on social media and collaborating with museums all over the world. This all with a social impact by helping people with a distance to the labor market. The museum has an unique collection which can not be found anywhere else and it only keeps on growing in impact. Currently (early 2022) being the computer heritage expert for the Dutch government.

The HomeComputerMuseum opened its door on March 17, 2018 and went nearly bankrupt by the end of 2018. But we pulled through and from the beginning of 2019, we managed to turn it around. Starting with a collection of roughly 35 computers, 4 active board members, 3 volunteers and an empty building without electricity we built the museum. By the end of 2021 we have over 500 computers in the active museum and another +/- 2500 computers in storage. 1500 CD-i titles, 2203 boxed PC games, over 4000 unique software titles and over 3000 manuals. Open 7 days a week in a 1090m2 location in the city center of Helmond with 40 volunteers and 6 board members. All without big sponsors and no subsidy we are researching the history, sharing the history, recreating the history by allowing everyone to use the old computers. From the only working Aesthedes2 (which is repaired by in-house technicians) to the computer used for the movie Titanic. We do digital heritage (read old media) and offer repairs to both new and old computers. We created a functioning business model that is world renowned and ready for anything to come and we love to share what we went through and why we are considered as an essential part of the Dutch heritage.. all in less than 4 years.

Fuzion is a modern general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects.

This talk will focus on Fuzion's aspects related to safety-critical software development. A fundamental idea of Fuzion is to provide a simple language at a high level of abstraction and move implementation decisions from the developer to the compiler. To enable this, the language defines a simple but powerful intermediate representation for static analysis tools to operate on.

Furthermore, pre- and post-conditions for design-by-contract are provided in a way that enables different levels of verification: static analysis as well as dynamic checks at different levels from safety to debugging.

Fuzion does not support exceptions, a run-time error has to be part of the result of a call and must be checked explicitly. Fuzion does not support dynamic loading of code. Numeric operations such as 'infix +' check for overflow.

Fuzion applications consist of a set of library modules and a main modules. Modules are verified for correctness individually as well as whole applications. This is possible since dynamic loading of code is not supported.

Introduction

Fuzion is a modern general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects.

Fuzion was influenced by many other languages including Java, Python, Eiffel, Rust, Go, Lua, Kotlin, C#, F#, Nim, Julia, Clojure, C/C++, and many more. The goal of Fuzion is to define a language that has the expressive power present in these languages and allow high-performance implementations and powerful analysis tools. Furthermore, Fuzion addresses requirements for safety-critical applications by adding support for contracts that enable formal specification and enable detailed control over run-time checks.

Many current programming language are getting more and more overloaded with new concepts and syntax to solve particular development or performance issues. Languages like Java/C# provide classes, interfaces, methods, packages, anonymous inner classes, local variables, fields, closures, etc. And these languages are currently further extended by the introductions of records/structs, value types, etc. The possibility of nesting these different concepts results in complexity for the developer and the tools (compilers, VMs) that process and execute the code.

For example, the possibility to access a local variable as part of the closure of a lambda expression may result in the compiler allocating heap space to hold the contents of that local variable. Hence, the developer has lost control over the allocation decisions made by the compiler.

In Fuzion, the concepts of classes, interfaces, methods, packages, fields and local variables are unified in the concept of a Fuzion feature. The decision where to allocate the memory associated with a feature (on the heap, the stack or in a register) is left to the compiler just as well as the decision if dynamic type information is needed. The developer is left with the single concept of a feature, the language implementation takes care of all the rest.

Fuzion Feature Declarations

A Fuzion feature has a name, similar to the name of a class or a function. The main operation that can be performed on a feature is a feature call. The constituents of a feature declaration are as follows:

Formal Arguments

Features may have a list of formal arguments, which are themselves features implemented as fields. On a call to a feature with formal arguments, actual arguments have to be provided to the call, unless the list of formal arguments is empty.

Feature Result

The result of a feature call is an instance of the feature. Alternatively, a feature may declare a different result type, then it must return a value of that type on a call.

Closures

Features are nested, i.e., every feature is declared within the context of an outer feature. The only exception is the universe, which is the outermost feature in Fuzion. A feature can access features declared in its outer feature or, recursively, any outer feature of these outer features. This means, a feature declaration also defines a closure of the feature and its context.

When calling a feature f1 declared as an inner feature of f2, the call must include a target value which is the result of a call to f2, e.g., f2.f1.

Generics

Features may have generic type parameters. E.g. a feature declaration may leave the actual type used within that feature open and to be defined by the user of the feature.

The list of generic type parameters may be open, i.e., the number of actual generic type parameters is not fixed at feature declaration. This turns out to be useful in the declaration of choice types and functions as explained below.

Inheritance

Fuzion features can inherit from one or several other features. When inheriting from an existing features, all inner features of the parent automatically become inner features of the heir feature. It is possible to redefine inherited features. In particular, when inheriting from a feature with abstract inner features, one can implement the inherited abstract features.

A redefinition of an inherited feature may implement an inherited feature as a routine or as a field. An inherited feature that is implemented as a field, however, cannot be redefined as something else since fields might be mutable.

Inheritance may result in conflicts. An example would be two features with the same name that are inherited from two different parents. In this case, the heir must resolve the conflict either by redefining the inherited features and providing a new implementation or by renaming the inherited features resulting in two inner features in the heir feature.

Inheritance and redefinition in Fuzion does not require dynamic binding. By default, the types defined by features are value types and no run-time overhead for dynamic binding is imposed by inheritance.

A Contract

A feature may declare a contract that specifies what the features does and under which conditions the feature may be called.

An implementation

Features must have one of the following implementations

• a routine is a feature implementation with code that is executed on a call

• a field is a memory slot that stores a value and whose contents are returned on a call

• an abstract feature has no implementation and cannot be called directly, but can be implemented by heir features

• an intrinsic feature is a low-level feature implemented by the compiler or run-time system, e.g., the infix + operator to add two 32-bit integer values may be an intrinsic operation.

A feature implemented as a routine can contain inner feature declarations.

Feature examples

Here is an example that declares a feature point that functions similar to a struct or record in other languages:

point(x, y i32) is # empty
p1 := point 3 4
say "p1.x is {p1.x}"    # will print "p1.x is 3"
say "p1.y is {p1.y}"    # will print "p1.y is 4"

The next example shows a feature base that provides an inner feature plus that adds its argument to the value passed to the enclosing base:

base(v i32) is
  plus(w i32) => v + w

b1 := base 30
b2 := base 100
say (b1.plus 23)    # will print "53"
say (b2.plus 23)    # will print "123"

Design-by-Contract

Fuzion features can be equipped with pre- and post-conditions to formally document the requirements that must be met when a feature is called and the guarantees given by a feature. An example is a feature that implements a square root function for 32-bit integers:

sqrt(a i32) i32

pre
  safety: a >= 0
post
  debug: result * result <= a,
  debug: (result + 1) > a / (result + 1),
  debug: result >= 0

is

if a == 0
  0
else
  for
    last := 0, r
    r    := 1, (last +^ a / last) / 2         # +^ performs saturating addition
  until r == last

In this case, the function defines the pre-condition that its argument 'a' is non-negative. A call of this function with a negative value will result in a run-time error. On the other hand, its post-conditions make a clear statement about the result: The result will be the largest value that, when squared, is less than or equal to 'a'.

Checking Pre- and Post-conditions

Pre- and post-conditions can be classified for different purposes. Default qualifiers provided in the standard library are

safety

This qualifier protects pre-conditions that are required for the safety of an operation.

An example is the index check pre-condition of the intrinsic operation to access an element of an array: Not performing the index check would allow arbitrary memory accesses and break the application's safety.

This qualifier should therefore never be disabled unless you are running code in an environment where performance is essential and safety is irrelevant.

debug, debug(n)

This qualifier is generally for debugging, it is set iff debugging is enabled or enabled at the given level, respectively..

pedantic

This qualifier is for conditions that a pedantic purist would require, that otherwise a more relaxed hacker would prefer to do without.

analysis

Qualifier for conditions that are generally not reasonable as run-time checks, either because they are prohibitively expensive or even not at all computable in this finite universe. These conditions may, however, be useful for formal analysis tools that do not execute the code but perform techniques such as abstract interpretation or formal deduction to reason about the it.

Additional user defined qualifiers may be added, any expression resulting in a 'bool' can be used.

Run-time checks for pre- and post-conditions can be enabled or disabled for each of these qualifiers (except for 'analysis', which is always disabled). This gives a fine-grain control over the kind of checks that are desired at run-time. Usually, one would always want to keep safety checks enabled in a system that processes data provided from the outside to avoid vulnerabilities such as buffer overflows. However, in a closed system like a rocket controller, it might make sense to disable checks since a run-time error would mean definite loss of the mission, while an unexpected intermediate value may still result in a useful final result of a calculation.

Explicit results instead of Exceptions

Instead of exceptions that provide an alternative path for a function to return, Fuzion requires all functions to return a result. To indicate failure, the generic result type 'outcome' is provided.

outcome is a choice type that represents the result of a routine that may either produce something useful or fail producing an error condition.

Here is a small example of using an outcome result

getData (u User, t Type) outcome<data> is

if u.allowedToAcces T
  (readFile t.fileName)?
else
  error "user $u not allowed to access $t"

readFile (n string) outcome<data> is

if dataExists n
  readData n
else
  error "data $t not available"

A user of this code when would have to explicitly unwrap the read data as follows

o := getData user type match o

d data  => say "success: $d"
e error => say "*** error $e"

Fuzion Modules

Modules in Fuzion are collections of Fuzion features that form a library to be used by other modules. Modules may define a main entry point, such that they can be used to build applications.

The Fuzion front end performs static code analysis at the module level. This means that any features exported by a module are save to be used in different contexts by other modules. This includes static checking of the following aspects:

Field Initialization

In Fuzion, the front end ensures that all fields are assigned an initial value. There is no default initial value for uninitialized fields and there is no means to access an uninitialized fields, as there is, e.g., for final fields in Java.

Instead, it is checked that whenever an instance containing a field becomes accessible outside of the feature declaring that field, the call chain is analyzed to ensure it may not contain any accesses to the field. In particular, if an instance may become visible outside of the module, no uninitialized field may be accessible by any exported features of that module.

Function Purity

The result of any feature visible to the outside must be independent of state modifiable by other exported features and must not itself modify state that may affect the result of other exported features. This purity will allow optimizations such as memoization or lazy evaluation common in functional languages.

Nevertheless, a pure function may use mutable fields, e.g., to store intermediate results during its calculations. If the mutable field's life span is limited to the call of the exported feature and the field is not accessed by any other exported feature, mutation does not make a function impure.

Race Freedom

Closely related to function purity is race freedom: Any exported feature is checked to be safe to be called in a threaded environment without causing data races. There are no explicit locks in Fuzion, so there is no danger of deadlocks due to nested locking.

Immutability

Fuzion encourages the use of immutable data by simple syntax for the declaration of immutable fields. Also, the use of tail calls for loops automatically converts iterator variables used in that loop into immutable variables with a life span of a single loop iteration.

Since immutability is essential to ensure correctness of parallel execution within threads that do not rely on locks or similar synchronization mechanisms, Fuzion's analyzer will verify that data shared between threads is immutable.

The standard library has been designed to provide immutable data types. Nevertheless, there are mutable types such as 'marray', which provides a mutable array. These, however, should be used for local calculations only, escape analysis will ensure that no accesses to mutable types occur from outside the code manipulating the state.

Memory Management

Fuzion to a large extend relies on static analysis to reduce memory management overhead. Instances are by default value instances that do not require heap allocation. Furthermore, immutability in many cases avoids the need to keep a shared copy on the heap. For dynamic calls, heap allocation and dynamic binding overhead is avoided by specialization of calls.

Only for those instances for which all of these optimizations would fail, in particular instances shared between threads or long-lived instances with mutable fields, heap allocation will be required. Memory allocated on the heap will be reclaimed by a real-time garbage collector.

Fuzion Thread Safety

Static analysis at module and application level ensure that mutable data is not shared between threads in Fuzion. However, there must be means for threads to communicate, e.g., for the result of a thread to become available to other threads. How this will be done in Fuzion is still open, thread safe libraries such as thread-safe queues between might be provided here.

Conclusion and Next Steps

I hope Fuzion shows some interesting ideas how to approach the development of safety-critical software.

The Fuzion language definition and implementation are far from stable, but are getting closer to become useful. Currently, two execution options for Fuzion are available: An interpreter implemented in Java and a back-end that compiles to C code. A tool to interface Java code is available for the interpreter.

Main points that are missing right now are

• a powerful standard library
• additional library modules for all sorts of application needs
• low-level foreign language interface for C
• actual implementations of static analyzers and optimizers
• highly optimizing back-ends
• garbage collection for the C back-end
• documentation, tutorials
• enthusiastic contributors and users!

Please feel free to contact me in case you want to use Fuzion or want to help making it a success!

The confidentiality and integrity guarantees offered by Intel SGX enclaves can be easily thwarted if the enclave has not been properly designed. Its interface with the untrusted software stack is a perhaps the largest attack surface that adversaries can exploit; unintended interactions with untrusted code can expose the enclave to memory corruption attacks, for instance.

We have proposed a notion, called orderliness, that embodies good practice set out by academic papers and the principles of the Intel SGX SDK’s programming model. It is concerned especially with these interactions between the trusted and untrusted worlds. This notion underpins Guardian: an open-source tool that we have created to help enclave developers check their enclaves are orderly before they are deployed. It automatically validates enclaves and reports violations to our notion of orderliness. These violations help find parts of their code that may need changing – they should usually point to an attack primitive.

We have found some security issues in enclaves that had been extensively vetted by other researchers – one of which was crafted by Intel engineers.

Modern processors can offer hardware primitives that allow a process to run in isolation. These primitives implement a trusted execution environment (TEE) in which a program can run in such a way that the integrity and confidentiality of its execution are guaranteed. Intel's Software Guard eXtensions (SGX) is an example of such primitives and its isolated processes are called enclaves. These guarantees, however, can be easily undermined if the enclave has not been properly designed.

We propose a notion of an orderly enclave that splits the enclave’s behaviour into the following execution phases: entry, secure, ocall, and exit. Each of them imposes a set of restrictions that enforce a particular policy of access to untrusted memory and, in some cases, sanitisation conditions. A violation of these policies and conditions might indicate an undesired interaction with untrusted data/code or a lack of sanitisation, both of which can be harnessed to perpetrate attacks against the enclave. We also introduce Guardian: an open-source tool that uses symbolic execution to carry out the validation of an enclave against our notion of an orderly enclave; in this process, it also looks for some other typical attack primitives. We discuss how our approach can prevent and flag enclave vulnerabilities that have been identified in the literature. Moreover, we have evaluated how our approach fares in the analysis of some enclave samples. In this process, Guardian identified some previously undetected security issues in some of these samples. These were subsequently acknowledged and fixed by the corresponding maintainers.

It has been an exciting year in the open-source database industry, with more choice, more cloud, and key changes in the industry. We will dive into the key developments over 2021, including the most important open-source database software releases in general, the significance of cloud-native solutions in a multi-vendor multi-cloud world, the new criticality of security challenges, and the evolution of the open-source software industry.

The concerns about code complexity, cybersecurity and LTS have made a continuous testing infrastructure a must have.

The tests must take place both in virtual and real target. Virtual target because developers never get enough physical boards to test from, and real in order to limit virtualization/reality deviation.

With the exponential growth of software complexity, to keep the cost and time of critical embedded application development under control, a continuous testing infrastructure is a must have feature.

Not only should software tests be run early and automatically each time a developer pushes a new code commit in the system, but tests should also be run in a virtualized environment because developers typically never get enough physical board to test from. Nevertheless we should keep enough real hardware in the loop to limit virtualization/reality deviation and ensure developers can transparently move test from virtualization to the real world.

This presentation shows how virtualization can ensure early code integration to reduce development/testing cycle, while at the same time keeping track with real hardware to ensure that application is also running correctly on the final production device. Then it gives feedback on the different challenges Iot.bzh faced while deploying its continuous tests infrastructure. Finally it focuses on the way virtualization and real targets can be combined to offer developers a complete and efficient CI infrastructure.

The presentation will discuss current state of GRUB upstream development.

At FOSDEM 2021, we shared an introduction to, and the ambitions of, the Bitcoin Design Community. 6 months into the effort, we were brimming with ideas and big goals for designing amazing user experiences, connecting designers with open-source projects, and lots more. Now, one year later, we’d like to look back and share where we are, what has worked for us, and what hasn’t (yet?).

This is the story of how we harnessed the power of the community, automation and good habits to reduce our issue burden and helped users be heard.

5 years into its life and with vast number of users users, Element - a Matrix messaging client available on most desktop platforms, Android and iOS - had a growing backlog of bugs and enhancement requests. This is a common challenge faced by projects as they mature. I will share some of our lessons learnt and good practices that we have developed, and how our enthusiastic community is helping catch bugs earlier and process our backlog. While we have made good progress, we recognise that there are still further improvements to be made and will share some of our ideas for the future.

A short introduction about JavaScript Devroom with some interesting resources about JavaScript and a presentation about this special day for the FOSDEM JS Devroom.

Panel discussion between speakers of the visual inquiries session.

After a short introduction to the ngspice circuit simulator the first part of the talk will present some new features available in ngspice-36. Among them are SVG plotting capability, acknowledging RKM notation (e.g. 4k7 for 4.7 KOhm resistance), new and improved convergence methods when calculation the operating point, and many others.

The second part of the talk discusses some new features under development or still under discussion, like XSPICE memory management improvements, adding BSIMCMG model for FinFETs, adding IBIS capability (together with KiCad and sparselizard), and S parameter intgration. A lot of discussions is going on among FOSS simulator developers and users about better Verilog-A support.

Lunch break

The MariaDB optimizer has its roots in the original MySQL optimizer. Being a long standing project, it has inherited a number of quirks and features that -at the time of coding- made sense. The datasets had different sizes 10-20 years ago and the cost model is not always accurate for current workloads.

Thus, there is now an ongoing effort to significantly improve the calculations that the MariaDB Optimizer is doing. With the addition of JSON Histograms, the range optimizer is one of the most impacted modules. The end goal of this effort is to provide the user with a better query optimizer, but also put the user in control and allow the user to tweak many more parameters than were previously available. In this talk I will go through the major changes that are upcoming in MariaDB, changes that could impact query performance (for the better) and also raise awareness about which parameters have the highest impact on query optimizer performance.

OpenMandriva and its predecessors have been in the desktop and server world since the 1990s - now OpenMandriva 4.3 can run on the PinePhone. What did we have to do to get there and what problems have to be solved before it can fully replace that Android phone in my pocket?

Porting to the ARM (64-bit) architecture was relatively easy (and needed for some other projects). Modifying the build system to handle bootloaders other than grub and distribution formats other than iso images and special per-device kernels? Easy to hack but not that easy if you want to do it right. We needed to do something that doesn't go quite as far as OpenEmbedded/Yocto, but still is powerful enough to handle many different devices. Making the hardware work? Largely solved by the upstream community. Finding or developing apps for base functionality, and making them work for the phone form factor? Mostly solved (with a few caveats). But how can we work with Android and/or iOS apps (currently required to e.g. log in to most bank accounts)? How can we make this appealing to a normal user?

Open Source virtualization is almost 20 years old. Obviously, things have evolved a lot in that time: the public cloud, new CPU architectures, new storage technologies, and more.

What about the real, on-the-ground usage? Sysadmins, Ops and Devops are not leveraging virtualization the same way today as they did before. But what really changed? In what direction is it evolving? Is on-premise open source virtualization still relevant today?

Through our own journey as engineers of an open source virtualization platform, we'll give you an inside look into what our users are requesting from us, and what we did to modernize our virtualization stack based on the Xen hypervisor.

Talk about the "CV Project" app, which is a native Android app to contribute to Mozilla Common Voice via the smartphone.

This is a talk about Nim's concurrency mechanisms, how the old things worked, how the current things work and what the future holds.

Did you face the difficulty of choosing a right architecture solution for a specific project or a client while considering their “rather” complex environment? Do you feel like you need to change your tech stack continuously?

If the answer is yes to both of the questions, join my talk about the solutions I’ve found so we can ca discuss your best practice as well.

Accelerators (technology kits) are opinionated yet pragmatic that I’ve identified and tested on the projects in production. They allow me to go faster on delivering high-quality code with an easy to master architecture, to on-board other team members on the project and increase their productivity without reinventing everything from scratch.

We will discuss about the main JS frameworks (Vue.js, React, Svelte, Angular) and their meta-framework (why use them?), the state management (local and server state), the accessibility (how to integrate it from the beginning?), the testing and styling (CSS, SCSS, CSS-In-JS, Tailwind, which one to choose?).

Of course, take everything that will be said in this talk as an opinion, not as an absolute word because there is only one way to develop.

Be ready to share your tips during Q&A session.

Once you start out in embedded linux, there is a lot to do. Some things are obvious, some less so. First and foremost, you can put your knowledge of using Linux on the desktop to good use, right? This approach feels like a natural progression, but it has its pitfalls - some of which this talk aims to help you understand and ultimately avoid.

Building and developing an embedded linux system sometimes feels like magic. It's all open source, right? You can just grab the code and make it do your bidding!

But just like the Sorcerer’s Apprentice in the poem, you might find yourself struggling with the spirits that you just called, like What a “Distribution” is, and why is it important that you know Why package management is so different Where configuration happens, and where not When to update, and what

This talks covers five of the most common misconceptions that beginners have when they cast their first spells in embedded linux, not only to avoid them backfiring - but to actually harness the power.

DebConf has been online for two years using a combination of our in-person infrastructure and new tools. This talk will describe both setups and what has been done to bring DebConf online.

Discussion about the way to work on translating UI and Help.

This talk explores the interconnections that links Research Software (RS) dissemination and evaluation issues, in the Open Science context, following the guidelines of the CDUR RS assessment protocol.

In our presentation of FOSDEM 2021:

Free/Open source Research Software production at the Gaspard-Monge Computer Science laboratory - Lessons learnt https://archive.fosdem.org/2021/schedule/event/openresearchgaspard_monge/

we have analyzed the evolution of several problems that rise when considering the Research Software (RS) production of a laboratory, and we have highlighted several issues that should be addressed to deal with these problems within the Open Science context. Among them we have called to the establishment of sound dissemination and evaluation procedures following the guidelines of the CDUR RS assessment protocol presented in:

Gomez-Diaz T and Recio T. On the evaluation of research software: the CDUR procedure. F1000Research 2019, 8:1353 https://doi.org/10.12688/f1000research.19994.2

CDUR comprises four steps that can be succinctly described as follows:

• Citation, to deal with correct RS identification,
• Dissemination, to measure good dissemination practices,
• Use, devoted to the evaluation of usability aspects, and
• Research, to assess the impact of the scientific work.

In this talk we would like to analyze more in depth RS dissemination and evaluation issues and the above mentioned protocols, referring, in particular, to how these protocols can be adapted to different situations that may appear in evaluation processes such as, for example, different evaluation contexts (career, review...).

We will also highlight the interconnections that link both dissemination and evaluation issues, as the RS dissemination needs to adjust to evaluation rules and only suitably disseminated RS (maybe in a restricted context) can be evaluated.

This is a collaboration work with Tomas Recio, Professor at the University Antonio de Nebrija (Madrid).

Rakulang is great not only as a scripting language, but also at the conceptual level, allowing you to map problem-domain concepts to data structures easily. This comes handy when you use a specific kind of learning procedure that needs to track general class progress as well as individual attainment levels in a very precise way. In this context, we have created a Raku mini-library and a series of scripts that give us information on how a whole class of Cloud Computing students is progressing, and allows to pinpoint choke points, hurdles to progress, as well as individuals who might have been left behind.

We think that teaching software engineering should be just like software engineering, and in this context we have created a class with project-based learning, and objective-based learning. Students progress asynchronously through a series of objectives, with the student giving them individualized feedback on how to achieve those objectives. Objectives fulfillment is public, and this gives us a storage platform on which to build a series of scripts that show us the general degree of attainment by the class, as well as how every individual students are doing. These scripts are, for the time being, run manually. In the near future they will be integrated in a learning analytics workfow using GitHub actions, reducing the amount of manual running as much as possible. This, while not using a big amount of high-magic, shows how Raku expresiveness and whippipitude make the management of class extremely easy.

A brief introductory talk on Java 17's New project Panama APIs to get your feet wet into the world of native language access or better known as Foreign Function Interface APIs (JEP 412).

As a Java developer, you may have a need to access native libraries, such as Tensorflow, SqlLite, ffmpeg, OpenGL, but later find that JNI is your default choice. JNI (Java Native Interface) requires native code to be installed. You’ll quickly find that JNI wrapper code is difficult to maintain. New to OpenJDK 17 is the Foreign Linker API (JEP 412) as a replacement or alternative for JNI to provide a pure-Java solution and perform comparable to, or better than, JNI. The aim of this talk is to help you be proficient at creating Java programs capable of accessing devices and/or native libraries mainly focussing on OpenJDK 17’s Foreign Linker API.

• Intro (what, why, where)

• Requirements

• IDE, environment setup

• Getting started

• Anatomy of a Hello World in C

• What is jextract

• Panama Hello World in Java

• How to allocate memory to work with C primitives, arrays, & C strings.

• How to allocate and mimic pointers, structs, and array of structs.

• What are VarHandles?

• What are MethodHandles?

• Using your super powers to access system libraries

• Using your super powers to access third party libraries (demos)
 Demos may include: OpenGL, LeapMotion device, Git, ffmpeg, Python, Swift, MacOS touchID, MacOS SpeechSynthesizer.

All Code will be available online at https://github.com/carldea/panama4newbies

In this talk, we explore the design of Managarm's microkernel. Managarm is a pragmatic microkernel-based OS with a focus on asynchronous operations. The talk covers various aspects of the microkernel, such as its IPC model, resource management, and user space API. Managarm's microkernel employs a capability-based design to manage hardware resources. In contrast to current mainstream OSes, Managarm's system calls never block but report completion asynchronously whenever possible. This includes system calls for common tasks such as memory management or inter-process communication (IPC). A lock-free ring buffer is used to quickly deliver asynchronous completion notifications to user space. Managarm implements a POSIX subsystem to be able to run various well-known UNIX applications (e.g., a Wayland desktop) on top of the microkernel. This subsystem is implemented entirely in user space. The kernel uses various acceleration strategies to to efficiently support this use case.

French citizens have a right to request source code developed by their administration. This includes source code developed by public research labs. But the research sector has a distinct place in the "public code" landscape. It produces open source gems like scikit-learn, and many researchers contribute to Free Software, but some source code is never published because public labs are requested to use them as assets for new startups. This talk will explore this distinct place, the work that has been done in France to promote the publication of research source code and the challenges ahead.

A warm welcome to The Go Devroom at FOSDEM 2022

Contributions to Open Source Projects are always encouraged, especially from Newcomers and Non-coders. However, actually contributing as someone not familiar with the project, its workflows and its tools is usually everything but simple and requires a substantial time investment. This is especially the case if you are not a programmer or not as experienced with the technology in use, which can ultimately discourage otherwise potential willing contributors.

This talk will illustrate concrete steps that you, the maintainers of Open Source Projects, can undertake to simplify the hoops one has to jump through for their first contribution. We will cover various tools that you can use for this, be it for communication, localization, editing or publishing, how to provide good introductory material and how to build a welcoming atmosphere.

REST, the architecture underlying the web's protocols, has proven its benefits in creating a globe-spanning, decentralized information network. However, REST is showing its age - it was designed when surveillance capitalism, identity theft, information warfare, and other threats were largely hypothetical concerns. Unavoidably, REST leaves many of these issues unaddressed. Best practices fill some gaps, but may not be universally adopted.

The Interpeer Project has been awarded a grant from the Internet Society Foundation for research and development into a next generation architecture that addresses current and future Internet user needs. Such an architecture needs to embrace the strengths of REST, incorporate known best practices, but ideally make worst practices impossible.

This talk presents the issues with REST in some detail and lays out proposed solution sketches. The ideal is to invite participation, however. The 'net needs a wide range of view points to be fixed.

In 2000, Roy Fielding published his dissertation on Representational State Transfer. Fielding had been actively working on the HTTP standards, which were guiding by informal design principles that REST formalizes. The talk will revisit this architectural style to disambiguate it from how the REST term has become applied since.

Much as software freedoms exist, we need to address "internet user freedoms", and their relationship to human rights. Existing internet technology must be evaluated in this light, in how it supports or hinders human rights.

In this presentation, architectural properties and constraints in the REST architectural style will be analyzed, with regards to the previous discussion as well as technical requirements. We will explore additional properties, and their effect on the architectural style.

The talk will also provide background on concrete work already done or underway on this and adjacent topics.

Finally, we'd like to briefly introduce the non-profit organization created to support work on this project. If we are to create a better digital world, we'll need patience and all the help we can get.

Time tracking is a task many people have to deal with. Be it for writing bills for your client, creating time reports for your company, or simply because you are curious what you are doing with your time all day. Timewarrior is a tool that lets you track your time easily from the command line – it does its job then gets out of your way.

The presentation wants to give you an overview of what Timewarrior can do for you (and what not), and how you can adapt Timewarrior to your needs.

The talk is aimed at new users, but everyone is welcome to join the Q&A session afterwards.

DirectFB2 is a fork of DirectFB, a graphics library designed with embedded systems in mind that was widely used in the GNU/Linux embedded world. DirectFB2 comes with changes such as a Meson build system, a pure C implementation and a modularization of the source code.

Access to the low-level display is based on a DRM/KMS system module (or possibly on a legacy Framebuffer system module), and depending on the platform, hardware-accelerated graphics rendering can be achieved using the architecture of the GFX driver modules.

The core library is very light (no external dependencies) and provides basic font/image/video rendering support which can be demonstrated with the DirectFB-examples.

The use of additional DirectFB providers based on external libraries is also possible thanks to the DirectFB-media package, such as rendering fonts with the FreeType library, rendering images with libpng or jpeg libraries, rendering videos with FFmpeg or GStreamer libraries.

For 3D graphics, OpenGL or Vulkan rendering can be done with the DirectFB graphics backend. As an example, the Mesa 3D implementation makes OpenGL rendering possible with a DirectFBGL module or with EGL for the DirectFB platform, and the SwiftShader implementation makes Vulkan rendering possible with the DirectFB WSI.

This talk aims at getting started with DirectFB2 which may be worth considering on some devices.

Things like Infrastructure as Code, Service Discovery and Config Management can and have helped us to quickly build and rebuild infrastructure but we haven't nearly spend enough time to train our self to review, monitor and respond to outages.

With the the introduction of CI/CD best practices into our day to day workflows we protect ourselves for introducing "bad" code into production and exposing flaws to our (end-)users. But what about influences from bad actors in- and out-side our projects. This talk will focus on the additional steps we can add to our Waypoint build pipelines to also protect ourselves to so called supply chain attacks while running our jobs in Nomad. We ll discuss scanning for vulnerabilities in incoming code, packages and images and signing the content artifacts we trust before exposing them to our users.

From loading Ajax requests in browsers to have full-blown frameworks; Javascript has come a long way. While moving stuff from backend to frontend the problems of backend are also ported. The Bigger the code gets bigger the problems, more dependencies, harder maintainability, eventually all the problems of a huge monolith. With MicroFrontends, we can break this monolith into smaller independent, maintainable apps. Sounds good? Let’s see how in this talk.

In the modern app architecture, Frontend contributes a major chunk of the setup, most of the business logic is housed in the Frontend. Over time Frontend app becomes a huge monolith, harder to maintain, trickier to add new features, and so on. With Microfrontends we break this monolith into smaller independent apps. These apps are developed independently but stitched as a SPA on the fly with all the goodies of client-side javascript. This has been done traditionally with several approaches, but with Webpack 5 we now have Module Federation, which opens the door for seamless MicroFrontend integrations. In this talk, we will discuss the Microfrontends architecture pattern, how to destructure an existing monolith into MicroFrontends with help of Module Federation from Webpack 5. By the end of this talk, the attendees will be having a new vision of how they architect their Frontends.

I have started to teach OSS licences and compliances at a Japanese university since last year. it was difficult to teach OSS licences and compliances because I should have shown many of use cases so that the students could learn what the licences and compliance are and more, they even didn't know how to deal with ordinal software licenses. So, I had to talk many of the background knowledges to the students as an 'introduction' so that students could understand the OSS licences with compliances with ease. Fortunately, there were good feedbacks from the students, though, I need to improve my lecture more gathering more use cases etc. I will give a talk my experiences there at the university and discuss how to improve my lecture to teach such 'licences and compliances' to students. the feedbacks/ideas for my talk are really welcome!

I will give a talk

The opportunities to teach OSS licenses and compliances

1. increase the incidents of OSS licenses violation
2. keep compliances not to violate OSS licenses
3. respect the authors and keep the licenses rules.
4. reinventing of the wheel with compliances

the Difficulties to teach several OSS licenses

1. the difficulties for students to read several OSS license descriptions directly, really complex for them, especially GPL licenses.
2. need to gather many of the incidents of OSS licenses violation.
3. need to prepare good quiz(exam) so that students could understand with ease.

the lecture last year

1. why the University needs the lecture
2. the trial and error for the students
3. the advice from the staff at the university
4. the feedbacks from the students

the lecture coming next year

1. gather more incidents to check
2. looking into the incidents more - deep-diving for the practice.
3. looking into new OSS licenses for DX
4. any ideas...welcome!

The aim of this abstract is to showcase the enhanced debuggability support added in LLVM for the Fortran language features. LLVM being emerging compiler framework, there was some gap to be bridged w.r.t. Fortran language debug info generation. This is because Fortran language has few features which are very powerful, as compared to other languages.

Fortran dynamic arrays are one such powerful language feature. There are variety of arrays like adjustable array, assumed shape, assumed size, assumed rank, allocatable and pointer arrays. LLVM generated debug info was not sufficient to debug these many variety of arrays with GDB/LLDB. The LLVM was lacking support for multiple DWARF operators (DWOPpushobject address, DWOPover), DWARF attributes (DWATdatalocation, DWATallocated, DWATassociated, DWATrank) and a DWARF TAGs (DWTAGgeneric_subrange). Other than these, existing support for DISubrange was not sufficient to handle Fortran arrays. The same was true for Fortran strings which is not mere pointer to character type and needed more support from LLVM. Other features which needed similar LLVM support for debugging were Fortran modules, namelist and signed constants etc.

All these enhancements made in LLVM are as per DWARF4 or DWARF5 specification for the Fortran language. These enhanced debug info are used by GDB/LLDB and user debugging experience is improved now while handling these Fortran features with GDB/LLDB. In order to make use of these enhanced debug info emitted by LLVM, GDB/LLDB is also enhanced in cases where required. With these enhancements added now in LLVM, Fortran program debugging experience with the clang/flang emitted programs are on par with gcc/gfortran emitted programs and in some cases it’s even better than gcc/gfortran.

MySQL 8 and MariaDB 10.6 are the latest Major versions for MySQL and MariaDB. While MariaDB started by being slightly different MySQL variant, now it has grown into very much different database platforms which grows more different from every release.

In this presentation, we will look into the differences between MySQL and MariaDB in the core areas such as SQL features, query optimizations, replication, storage engines, and security. We will also discuss the unique features and capabilities MySQL 8 and MariaDB 10.6 offers compared to each other.

An overview of the Mozilla Support team and how a group of contributors spread all across the world work together to help users of Firefox, Thunderbird and other Mozilla apps.

It has been well established that the integrity of critical systems must be rooted in the launch. Early works such as the Xoar architecture demonstrated the need for virtualized environments to begin with a lightweight, restricted bootstrap from which isolation of PCI management could be established. Since that time, knowledge of real IOMMU implementations and how to leverage them for system integrity has evolved. In this presentation, the new Hyperlaunch capability for starting hypervisors will be presented with a short discussion of the Xen implementation. The talk will progress to a discussion of how Hyperlaunch is connected with TrenchBoot (Linux Secure Launch) and Mandatory Access Control communication fabrics. With a focus on how it enables dedicated PCI management constructs that can provide secure and trustworthy isolation for PCI devices, with the potential for CXL devices. The talk will close with an open discussion on how hypervisors might unify around a common approach for IOMMU management.

Discussion between the Policies panel speakers.

This talk builds on my previous talks about micro-controller programming in Nim, and my talk on writing a keyboard firmware from scratch in Nim. It outlines how a Nim ecosystem for microcontrollers can be built with zero-cost abstractions which means that the resulting code is almost exactly the same size as pure C code (no Arduino). All this while keeping an interface which is much nicer than anything you'd find in C, maybe even better than that of high-level microprocessor coding frameworks like MicroPython and TinyGo.

In light of the pandemic, the foss-north conference has gone virtual since 2020. In this presentation we will discuss our live streaming and video recording setup built around OBS, Jitsi and Kdenlive.

The talk will discuss what software we are running, how and some behind the scenes info about how we run the live events, as well as how we edit and distribute the recordings post event.

This is the 3rd edition of the "Status of AMD platform in coreboot". The talk will cover the most recent news around the AMD support in open source firmware ecosystem and updates of the topics covered in previous years. We would like to present status of FSF RYF KGPE-D16 platform revival and related upstreaming effort, TrenchBoot progress for AMD platforms and status of recent support in coreboot and oreboot projects. Finally we would like to present Dasharo - open source firmware distribution with long term stable support for older AMD platforms.

The history of AMD cooperation in coreboot projects reaches 2007 where the first contribution appeared for the Geode LX processors. AMD's open-source support continued for many years until now (with some break). This presentation will briefly repeat the history of AMD and open source firmware. Moreover, recent coreboot releases started to enforce certain requirements on the features supported by the silicon code base. Aging platforms kept losing interest and many of them (including fully open ones) starting to cause unjustifiable overhead, because of accumulated technical debt. Most probably it will result in similar situation as with famous 4.11 branch becoming de facto stable branch for some platforms (e.g. FSP1.0 Bay Trail or ASUS KGPE-D16). Nowadays AMD is releasing the newest AGESA with the cooperation of hired coreboot developers, but charter covers modern Ryzen-based processors. We trying to support the AMD platforms by reimplementing the ASUS KGPE-D16 (FSF RYF platform) support in coreboot and keeping the PC Engines platforms in the top of tree. We would like to present Dasharo plan for long term stable and sustainable support for older platforms. If you are interested in open source firmware for most open x86 platforms on the market feel free to tune in and discuss the ideas with us.

Unikernels are hard to debug? Unikernels cannot be easily administrated or monitored? While unikernels have the potential to revolutionize our infrastructures and take cloud computing into the next era, many worry that unikernels cannot be seamlessly integrated into today’s development and production workflows. At the Unikraft team, we are heavily working on addressing these concerns and changing the status quo. Although unikernels are monolithic bundles of only necessary kernel functions and an application, we follow the concept that everything is a (micro-)library. Users can pick and choose kernel functionality at build time. The same applies for monitoring and debugging: In this talk, we will give an overview of our current debugging and monitoring capabilities, and we will present our vision for how these pieces will enable a cloud-native experience. We will also give a deep dive into our GDB backend implementation with a live demo.

Unikraft is an open source Xen Project incubator under the auspices of the Linux Foundation. We are currently launching a start-up with the mission to provide Unikraft unikernels for production and enterprise use.

Every programmer's dream is constantly building new features and seeing how the project grows. However, there is nothing worse than writing a lot of boilerplate code just before even start implementing those features. In this talk, you will learn about Flutter code generation tools and various tips on how to avoid implementing boilerplate code and focus on your next-gen project.

As a means of enabling distributed collaboration, open-source enables people from many different disciplinary backgrounds to participate in research projects to which they would otherwise not have access. Additionally, open-source allows for reconfigurable expertise, or the ability to combine people from different backgrounds in ways depending on the task at hand. This talk will discuss the challenges associated with spontaneous interdisciplinary, in addition to opportunities provided by reconfigurable expertise. Examples from three open-source communities: OpenWorm Foundation, Rokwire Community, and the Orthogonal Research and Education Lab. The community building aspects of maintaining members for this type of adaptive and resilient resource are also addressed. When applied to academic-based communities, the ability to reconfigure working groups based on both the immediate and long-term needs of expertise is a valuable model for project management.

A demonstration of log4j exploits, which defenses people tried, and which worked. We'll cover how groups responded effectively to patch to see what was common. We'll also look at open source funding models, subscriptions, and bug bounty programs to see why it's sometimes hard to donate.

This talk will use actual exploit code that takes over systems through their log messages to open calculators.

Slices, Maps and Channels in go, are first class citizens of the language, they are used widely in our day to day work, but… do you know how they works under the hood? Do you know the implications of adding elements to an slice, or new keys to a map?

Do you know why you can’t relay in maps order? Do you know how channels handle the buffer or the blocked goroutines? If you don’t know about that, this is your talk. I going to access the go runtime memory state of the maps, slices and channels, and show you how they evolve over time while we change them.

Debugging applications is an important part of the development process. However, error messages and general logging can leak sensitive data, and in some cases even compromise your whole stack, as developers worldwide have recently learned from the log4j vulnerability.

With Confidential Computing, the world gets much more complicated, as every piece of information that a malicious entity on the host (including the host itself!) can gather may be leaking vital information about your workload. This talk details some of the problems that arise, and discusses some options to address them whilst considering real life workloads and application lifecycles.

Log entries and other error messages can be very useful, but they can also provide information to other parties - sometimes information which you’d prefer they didn’t have. This is particularly true when you are thinking about Confidential Computing: running applications or workloads in environments where you really want to protect the confidentiality and integrity of your application and its data.

This talk examines some of the issues that we need to consider when designing Confidential Computing frameworks, the applications we run in them, and their operations. Designers and architects of the TEE infrastructure and even, to a lesser extent, of potential workloads themselves, need to consider very carefully the impact of host gaining access to messages associated with the workload and the infrastructure components. It is, realistically, infeasible to restrict all communication to levels appropriate for deployment, so it is recommended that various profiles are created which can be applied to different stages of a deployment, and whose use is carefully monitored, logged (!) and controlled by process.

Low and Middle Income Countries (LMIC) produce less than 10% of the world's scientific output, largely relying on solutions devised in the Global North, which are often unable to meet the real needs of their population. Data science and machine learning offer a unique opportunity to empower scientists in LMIC by providing cost-effective tools ideal for underfunded settings, but there is a gap in accessibility, infrastructure and skills that must be bridged before these tools can be effectively implemented. We are developing the Ersilia Model Hub, a FLOSS platform where scientists can browse through a catalogue of AI/ML models and run them without the need to write a single line of code. The platform features both models published in the literature and models developed by us on-demand or in collaboration with researchers in LMIC. The pilot tool focuses on models for drug discovery in infectious and neglected tropical diseases, but we plan to expand to other global health.

The Ersilia Model Hub is currently in alpha development, and it will be released in January 2022, containing 100 models. The MVP must be downloaded in the user’s computers and is accessible via a command-line interface. The models are fetched from our GitHub repository and run locally. They are designed to perform on regular personal computers. In the next phases, an online query system will be implemented for the most popular models, together with a user-friendly interface which does not require use of the CLI. In addition, we are working towards an end-to-end automated AI/ML pipeline to facilitate the creation and implementation of models trained on specific datasets of relevance to each of our users. This package will also be available early 2022.

The history of calculation, information processing and computation is very rich. It is driving the industrial revolution and digital transformation of our world. This history is composed of many events related to conceptual and technological breakthroughs. In order to help in the analysis (by researchers) and explanation (to citizens), the NAM-IP Computer Museum is actively developing the "Trajectware" Open Source framework based on a the structuration of illustrated events in the form of timeline fragments that can be explored using various navigation operations to focus on specific periods, aspects (technological, conceptual, cultural, contextual,...) or the involved people/organisations.

This talk is intended to everyone. It will first present the global design based on (1) a knowledge base back-end inspired by different ontology standards (SEM, DOLCE/Spatial History Ontology, Constructed Past Theory, DBPedia) and accessed through queries and/or a specific API to extract a relevant timeline, and (2) a navigation front-end, currently based on ReactNative. Different timeline navigation features will be illustrated on a concrete application case: the "micro-computer, meg@ revolution" exhibition of the NAM-IP museum.

Through our presentation, we hope to trigger interesting discussion about our current work and to gather suggestions and interests to grow this project !

In a traditional document driven process any changes to requirements need to be verified and validated manually. A solution is proposed to link requirements specifications to their implementation and track changes.

Integrating specifications documents into CI/CD pipelines enables the agile creation of always up-to-date documentation for the built/shipped artefacts. We link specific versions of specification items with code, tests, and other artefacts through their identifier and hash value.

Modern development practices have introduced continuous integration. It ensures that ingtegration steps create as little friction as possible. Furthermore all unit-tests are supposed to be succesfull at any given point in time.

Specifications documents can not trace this gap automatically and any changes on either side (implementation or specification) is subject to manual verification.

An extensible solution is proposed to link specification items with code (text) or any binary with a specific interpreter.

A demonstration is given how a hypothetical spacecraft has its tea brewer connected with Spacewire and the traceability is established. The data import from a DOORS Excel dump is shown and how to link it to a given specification.

I would like to share my experience bringing up various Automotive Ethernet Gigabit PHYs on an iMX8 platform.

Agenda:

• PHY configuration CheckList (= What I need to know about my PHY, my schematic before starting the bring-up)
• SW implementation (= step-by-step SW integration + common pitfalls to avoid, mainly focused on Linux, but I talk also about U-Boot)
• Debug tips (= SW and HW tips)

This presentation is based on a training I already gave internally in the Valeo Group (with some extra additions). This experience led to some patches that I hope to push at U-boot and Linux level.

In FOSDEM 2019 we presented the addition of high-performance virtual machines in oVirt. With this new VM type, parts of the VM configuration were changed to improve the performance of workloads it runs. In particular, it was useful for CPU-intensive workloads, such as SAP HANA. However, better performance came at the expense of usability. Users were still expected to set various things manually, like CPU and NUMA pinning and hugepages. In this talk, I will guide you through our journey of simplifying and automating the settings of high performance VMs in oVirt. We'll see the evolution of the changes, the challenges we faced, where we are today and what's more to come in oVirt 4.5.

The Mobian project was initiated a few days prior to FOSDEM'20, back when the first PinePhones (BraveHeart edition) were arriving in the hands of developers and enthusiasts. From a single-person weekend project aimed at running Debian on one specific device, to one of the major mobile Linux distributions, let's board into a journey through the past, present and future of Mobian!

Mobian started as a collection of hacks and scripts for running Debian on the PinePhone. Initially published as "Debian+Phosh" on the PINE64 forum, all packages were manually (cross) compiled and uploaded to the developer's personal web server.

Over time, it gathered a strong community of users and developers and ultimately gained recognition from the wider mobile Linux community, to the point where it partnered with PINE64 to release a "Mobian Community Edition" PinePhone. Over the course of its 2 years of existence, the project implemented tools to ease development and automate deployment, and added support for more mobile devices, such as Purism's Librem 5, but also Surface Pro tablets and a few Android phones such as the OnePlus 6 and Pocophone F1.

This talk will walk you through those 2 years of development, highlighting the project's contributions to the (mobile) FLOSS ecosystem. We will also emphasize how its members work, as part of the DebianOnMobile team, towards its ultimate goal of becoming irrelevant by making Debian a reference distribution on mobile devices. Finally, we will give you an update on the project's current status and plans.

Backup is typically done once a a day. But if you destroy your data hours later: What about the changes between your backup and the catastrophic event? In this presentation I will show you how you can recover your data between your backup until a specific point in time before the incident.

Open Document Format (ODF) and Office Open XML (OOXML) are both ISO/IEC open document standards, but while the first is loyal to standard definitions the second is an unfortunate attempt to propagate proprietary formats in a pseudo-standard format to lock-in users to Microsoft Office for the foreseeable future. The presentation explains why ODF is a better standard than OOXML.

XWiki is a structured wiki engine developed as Open Source since 2004, providing wiki-style collaboration for organizations, with many built-in features and countless extensions. XWiki has pioneered wikis by including structured data on the same level as free text content, thus enhancing significantly the expressiveness of the built knowledge bases; this same usage is also popularized by Confluence and Notion, with different user experience choices and more importantly with business models that are keeping user's data locked-in on the Cloud or in proprietary software.

In this talk we will present XWiki's journey to provide the best FOSS alternative to proprietary knowledge management tools, based on both current features and future roadmap.

We will showcase XWiki's approach for collaboration on text & structured data, including the newly conceived "livedata" component for inline editing of structured tabular data as well as the new realtime editor based on the realtime editing technology from CryptPad.

Last year we introduced the reasons and the plans for the new Digital Markets Act of the European Union, regulating online markets to further more competition with the dominant gatekeepers. In 2021, the act was discussed and finally voted by the European Parliament, which expanded many of its provisions and strengthened the new rules. In 2022, the act will be negotiated again with member States and then, possibly, finally approved by the Parliament. In this update we will explain in details what has changed and where we are.

The Digital Markets Act introduces rules for "gatekeeper" digital companies, defining how to recognize them and setting obligations for them to fulfil. These obligations generally affect their business practices, such as the terms and conditions that they impose onto their business users and the consumers; the way they enter new markets and exploit their strength to conquer them; the opportunities that are left for users to choose competing services or move out of the walled gardens. Principles like unbundling and interoperability have been recognized as useful tools to promote competition.

It is still to be understood whether all these obligations will survive the negotiation phases and will be confirmed in the final act. However, discussions are also starting on how some of these new provisions may be implemented, and how to define the details and the technical standards. The talk will present the current situation and solicit feedback and comments from the community.

In this talk we will briefly describe how to add your own extension to C, what steps may be needed to do it. And then we will review a small example

We want to summarize our findings, which we gathered during implementation of procedural-parametric extension for C. This work will present a list of examples about how to extend existing structures in clang, and how to map your new constructions from source code to LLVM IR More details about procedural-parametric approach: https://dl.acm.org/doi/10.1145/2556610.2556619 In that article you'll see examples of this extension implemented in Modula-like programming language. It will give you full picture about what we implemented in C

BIM (Building Information Modeling) is a paradigm for 3D CAD models made for Architecture, Engineering and Construction (AEC). Long a closed, proprietary garden, it becomes more and more an open, hackable world thanks to several Free and Open-Source tools and formats.

This talk will try to illustrate how rich that world has become when your tinkering, hacking, coding itch starts to scratch...

In this talk, Dion (developer of BlenderBIM) and Yorik (developer of FreeCAD, specifically its BIM tools) will use these two applications and try to show some clever tricks that you can do with BIM models, that no proprietary software would dream to achieve.

A desktop thermometer that displays relative humidity is useful, but it does not provide continuous monitoring. In comes the Raspberry Pi: it is small, inexpensive, and has many sensor options, including temperature and relative humidity. It can collect data around the clock, do some alerting, and forward data for analysis.

Originally it was a project to practice Python and learn Elasticsearch, but ended up with using syslog-ng between the two. Along the way, I also learned how to regulate humidity in my room. In my talk, I plan to cover the following topics:

• collecting environmental data on the Rasbperry Pi using Python

• configuring Elasticsearch to work around a syslog-ng limitation

• configuring syslog-ng to forward the collected data to Elasticsearch / OpenSearch

• take a look at the graphs in Kibana and learn how to keep humidity low in your room

I'd like to showcase LibVF.IO's new LIME Runtime feature (Lime Is Mediated Emulation) and do a deep dive on open source vGPU technology in general.

Some of the topics I would like to cover are the VFIO-Mdev API, the differences between Virgl vs. Hardware GPU virtualization (SR-IOV) vs. Software GPU virtualization (soft Mdev), various common GPU driver virtualization implementations (Intel i915, AMD GPU-IOV Module, and Nvidia), then talk about the benefits of hardware virtualization of GPUs for projects like Qubes OS and the ongoing effort to run LibVF.IO with Xen for use with Qubes. I'd like to share LibVF.IO's vision to bring vGPU SR-IOV functionality out of the datacenter and to most consumer devices running free software. Finally I'd like to explore what a world might look like if we're successful in bringing the benefits vGPU SR-IOV functionality to every day people running free software (native performance backwards compatibility via virtualization, hardware isolation, & workload balancing).

This talk will go through recent highlights of Thunderbird development. What are we working on for the mid 2022 release.

Typhoid fever is one of the severe infectious human diseases in Africa. Out of an estimated 11–21 million cases of typhoid fever and 200,000 deaths occur worldwide each year. Other elements contribute to this situation and particularly in rural areas where patients to doctors ratio is very low, lack of medical facilities and costly tests. There are a number of tests available presently, from molecular to immunological and biochemical to microbiological. However, Users are unsatisfied due to delays in getting test results and Imprecise diagnosis. Misdiagnosis is usually experienced since most health care facilities use only Widal test without confirmation of results with a second test method. In addition, the diagnosis of Typhoid involves several levels of uncertainties. Patients cannot tell exactly how they feel, doctors and nurses cannot tell exactly what they observe. There is therefore, an urgent need to develop a rapid, highly sensitive and cheap diagnostic tool for diagnosis of typhoid fever.

The absence of a reliable diagnosis pushes rural populations towards self-medication with all the consequences that this entails, in particular drug poisoning which can lead to death. As such, we want to develop a new method to diagnose Typhoid early, quickly, and with accurate results at a low cost. We propose a hybrid diagnosis method with a Deep Learning algorithm applied on blood serum images which seems to be the best accepted test by laboratory technicians. We use CNNs as algorithms on the collected images to train the algorithm. We use a second algorithm Rough Set Theory. This algorithm based on symptoms variables which are structured data collected from medical doctors allow us not only to confirm the diagnosis but above all to determine the level of severity of the disease and serve as a Decision Support System. The two algorithms will be part of a mobile app connected to an optical microscope, the phone camera will scan images from the slides on the microscope and classify them into Normal or Infected. In a series of rapid spotlights, we present tools and frameworks that serve as cornerstones for the envisioned diagnostics system including: 1) Values, influences and forces that shape the diagnostics 2) AI solutions to be used; 3) Data sources 4) Ethics and governance model.

While the coronavirus pandemic continues to send shockwaves throughout almost all industries, it’s important for developers to nurture their communities in a well-efficient way and prepare them for the future. The overwhelmed communication systems, improving remote culture, and fostering community coordination are the three main areas on which we need to focus on. It is important to recognize that community development is an organic process, the listed steps (not in order) are to be considered on how we empower people, communities, and the industries around us:

Learn about the community Listen to community members Bring people together to develop a shared vision Assess community assets and resources, needs and issues Help community members to recognize and articulate areas of concern and their causes Establish a 'vehicle for change’ Develop an action plan Implement an action plan Evaluate the results of actions Reflect and regroup

People want to live in resilient and healthy communities. Well-being and positive mental health start here. Further mental health services need to consider how they harness the assets and strengths of communities in developing approaches that empower people in their recovery journeys.

Mariabackup is a wonderful tool to perform physical online backups of MariaDB Server. By coupling it with Restic you can easily and efficiently create encrypted incremental backups of your DBs on the wide range of Restic's supported backends (local, sftp, s3, OpenStack swift, etc.).

In this talk Marta is going to present a map of the trusted computing landscape, explaining different types hardware support. She is going to put it in a context of implementing secure boot and trusted execution in an embedded distribution, namely Yocto-based Eclipse Oniro project.

The trusted computing landscape could be hard to understand for newcomers. Just at the beginning, they encounter a number of abbreviations like TEE, OPTEE, SEV, TF-A, TF-M and many more.

In this talk Marta is going to present a map of those technologies, illustrate how they are (or are expected to) be used, which market needs they address. She will show how they could be implemented in practice in an embedded distribution. The example will be the secure boot work in the Eclipse Oniro project, an embedded multi-OS distribution for Internet of Things (IOT) devices. The multi-OS specificity of Oniro will be used how the trusted computing technologies compare on different types of processors running Linux and Zephyr, with different security hardware support.

In this talk, we'll describe how OpenSecurityTraining2 (OST2) can help grow security talent and awareness on open source projects, and we'll use the coreboot open source firmware as a case study.

Newly structured as a 501c3 non-profit, OST2's core goal is to provide free and open training that helps increase system security. This can take multiple forms, such as training dedicated security engineers, training developers to write more secure code, training potential contributors to security-focused projects, or training engineers on safer alternatives to technologies they're already using. In this talk we'll describe current and future examples of all the previous use cases, and drill deeper into a case study of how 3mbdeb, a licensed service provider for the coreboot open source firmware project, is contributing to OST2 to advance the state of open source firmware security.

Serverless computing facilitates the use of resources without the burden of administering and maintaining infrastructure. The simplification of IaaS appears ideal (in theory) but providers and users are presented with several challenges: providers aim to reduce infrastructure maintenance overheads; users require isolation, flexibility and programming freedom.

Serverless deployments are mostly backed by sandboxed containers. To enable programming freedom for users, providers allow the use of containers for function deployment, however, to ensure strict isolation, these containers are sandboxed in VMs. As a result, this bloated stack brings complicated maintenance costs: (a) several layers of abstraction between the user function to be executed and the actual execution environment; (b) increased attack surface; (c) increased request-to-exec time; (d) reduced set of feature availability for functions (hardware acceleration).

Unikernels promise fast boot times, small memory footprint and stronger security but lack in terms of manageability. Additionally, Serverless frameworks only support containers. Moreover, unikernels provide a different environment for applications, with limited or no support for widely used libraries and OS features. This issue is even more apparent in the case of ML/AI workloads. ML/AI libraries are often dynamically linked and have numerous dependencies, which directly contradict the statically linked notion of unikernels. Finally, hardware acceleration is almost non-existent in unikernel frameworks, mainly due to the absence of suitable virtualization solutions for such devices.

In this talk, we present the design of a flexible serverless framework designed for the cloud and the edge, backed by unikernels that can access hardware accelerators. We go through the components that comprise the framework and elaborate on the challenges in building such a software stack: we first present an overview of the necessary components of a serverless framework; then we focus on the function execution framework based on two popular unikernel frameworks; finally, we present a hardware acceleration abstraction to expose semantic acceleration functionality to workloads running on top of this framework.

A short demo of the working components will be presented, discussing the challenges and trade-offs of this approach.

I have been organizing open-source related meetups and conferences for more than a decade. The past two years have been exceptionally trying. Any guesses as to why that is? :)

In this session, I will share our experiences from the 6 online Ansible Contributor Summits that we have held through 2020-2021. While the virtual platform gave us more flexibility in many ways (such as having 3 events in a year instead of the usual 1), it definitely presented many new challenges as well. From pre-event marketing to technologies used during the summits, post-event surveys + feedback that feed into the next event, it's a continuous cycle of trials, errors, and improvements.

There is also a major shift towards using open source tools and workflows for the summits, at the request of some community memebers as well as the desire within our team. I'll share what fell short and what thrived, and how the changes impacted not just conference management for our team, but also how the Ansible community received these events. Because at the end of the day, these conferences are for the community contributors and participants!

The lecture will discuss reverse engineering e-waste. It will shortly present the open source hardware tools that are used internally at Unbinare and how these are used when the aim is to reduce e-waste.

Error handling is one of Go’s key features. The errors.As helper added in Go 1.13 gives Gophers the tools they need to build their own error domains and ensure that all errors are handled properly across their applications.

The errors.As feature of Go 1.13 makes it easy to create error systems that work for your particular applications, users, and operators without being straitjacketed by the language into a one-size-fits-all approach that inadvertently exposes users to the internal operations of your system. Don’t let your end users be distracted by irrelevant warning messages. Handle errors properly by thinking about their roles and domain within your application.

Modern applications have tons of features and possibilities, and the more features there are, the harder it gets to be tested manually. Also, advocates for Test Driven Development makes testing even more important. In this session, we want to explore the possibilities of how to Test your Features in Dart and Flutter. We will discuss Unit, Widget and Integration tests in this session, what it is and why you will love the support in your next project.

So you’ve done some user testing or usability testing as an open source software team and now you have interesting user insights collected. But...what do you do with it? How does user feedback correspond to issues in the backlog? How do you get the wider OSS community team up to speed if they haven’t been part of the synthesis process? These are some of the questions you may ask yourself after participating in user testing or usability testing. You’re ready for a synthesis process!

The USABLE team has already published two resources about user testing and usability testing, now they are presenting their third resource about user insight synthesis. You’ll see how they supported open source software tool teams to work with user insights in an open source way of user testing, usability and synthesis work. In this session you will observe how the USABLE team supported OSS tool teams with user insight synthesis processes with detailed explanations of why, how and when to do synthesis. You will also view clips of a previous closed session in which the USABLE team and OSS tool teams collaborated on a synthesis work session.

So you’ve done some user testing or usability testing as an open source software team and now you have interesting user insights collected. But...what do you do with it? How does user feedback correspond to issues in the backlog? How do you get the wider OSS community team up to speed if they haven’t been part of the synthesis process? These are some of the questions you may ask yourself after participating in user testing or usability testing. You’re ready for a synthesis process!

The USABLE team has already published two resources about user testing and usability testing, now they are presenting their third resource about user insight synthesis. You’ll see how they supported open source software tool teams to work with user insights in an open source way of user testing, usability and synthesis work. In this session you will observe how the USABLE team supported OSS tool teams with user insight synthesis processes with detailed explanations of why, how and when to do synthesis. You will also view clips of a previous closed session in which the USABLE team and OSS tool teams collaborated on a synthesis work session.

Design and implementation of dynamic network attachment for Kubernetes pods and KubeVirt VMs.

Immutable infrastructure is the law of the land in the cloud native landscape, promising benefits to software architectures run in Kubernetes. … except sometimes the rules must be broken to achieve certain use cases; take for instance the dynamic attachment of L2 networks to a running VM: to hotplug an interface into the VM running in a pod, you first need to hotplug that interface into the pod.

This feature is particularly of interest (required, actually) to enable scenarios where the workload (VM) cannot tolerate a restart, or when the workload is created prior to the network.

When thinking about strategies for tackling this problem, we faced a recurring question when trying to come up with a modular design to provide this functionality: "should the changes be located in KubeVirt, and thus solve this issue for Virtual Machines, or should we take the longer path and address this issue also for pods ?" We chose the latter, which unlocks dynamic network attachment for pods, thus also benefiting the Kubernetes community.

This talk will provide the audience with a basic understanding of KubeVirt, CNI, and Multus, and then propose a design to add (or remove) network interfaces from running pods (and virtual machines), along with the changes required in Multus and KubeVirt to make it happen.

It will also factor in a community perspective, explaining how we pitched and got both the Multus and KubeVirt communities involved in a working arrangement to deliver this functionality.

Behavior Graph is a software architecture and state management library. It greatly enhances your ability to write complex user facing software and control systems.

Broadly speaking, it belongs to the category of libraries which includes Redux, MobX, Rx (Reactive Extensions), and XState.

It works by providing a new unit of composition which we call the behavior. Behaviors are simple blocks of code together with their dependency relationships.

We developed Behavior Graph to address our own complexity challenges while building an iOS video playing library which is used internally throughout the suite of native Yahoo mobile apps. After years of development and production usage, it has proven to be incredibly competent at scale.

We have since ported it to multiple languages including Javascript/Typescript. It is less than 1500 lines of code and contains no external dependencies.

Behavior Graph should appeal to anyone with an interest in software architectures and willingness to rethink how we write software applications.

Behavior Graph makes the dependency relationships between blocks of code its primary responsibility. We believe these relationships are the main source of complexity in most applications. Behavior Graph asks programmers to explicitly declare these dependency relationships. In exchange, it ensures that blocks of code are run at the correct time and in the correct order. As a result, the programmer is freed to reason locally about contained units of functionality, while the computer takes on the increasing complexity burden as an application grows in size.

In the presentation we will introduce the primary abstractions provided by Behavior Graph. We will do this by working through a simple example of how the library works with code samples. Then we will show how these pieces hold together as an architecture.

We will briefly touch on how it compares to similarly positioned libraries. Finally we will look at the current state of the library and a roadmap for the future.

Keeping your data secure is an important task of the DBA. We protect our servers, encrypt filesystems and/or datafiles. But what about log files? And especially log files that contain actual data such as the MySQL binary or relay logs. These are technically called log files but they contain the actual data going through your MySQL systems for replication purposes. I will describe how you can enable and use them and also, in case of disaster, how you can recover your encrypted binary logs so you can use them for point in time recovery.

Open Cascade Technology (OCCT) is a framework for B-Rep modeling. The lecture presents a technical update from the previous talk (at FOSDEM 2021). This year we also introduce our OCCT's Community Manager who will highlight community-related activities that happened during 2021.

Why is code open source, but data still locked into silos of big corporations? In this talk we asses the current situation of the web, and evaluate what we can do differently with Web3. We look into what it means for data to be "open source", the implications for developers as data is not locked into their apps, and the core pieces of technology that makes this possible.

As distributed systems evolve, the testing scale multiplies, asking for dozens of test cases, combined with different application benchmarks (e.g., performance, correctness), and arbitrary operating conditions. Kubernetes holds a promise to enable automation and process improvement directly contributing to a system's reliability. Establishing a declarative API and providing a cheap and disposable environment, Kubernetes makes it easy to create uniform experiments, which may run manually or be exercised multiple times over the development cycle through a CI/CD system. Despite their abundance, existing benchmarks and Chaos engineering tools work in isolation, thus restricting the complexity of testing scenarios we can build.

This talk will present Frisbee: an automated suite for the unified testing of distributed applications over Kubernetes. Frisbee simplifies a series of time-demanding activities, including the spin-up of the dependency stack required to bring the system into a steady state, the combined execution of workloads and faultloads, and the validation of the system's behavior via test cases. We will demonstrate Frisbee through a series of tests, focusing on uncertainties at the level of application (e.g., dynamically changing request patterns), infrastructure (e.g., crashes, network partitions), and deployment (e.g., saturation points).

Differentiating between architectural flaws and bugs in socio-technical systems: Open Source is no legal term or a political institution in dominant sovereign state systems, making it vague and interpretable in different contexts. However, it is a fundamental institution in security provisions in today's socio-technical societies. But it remains impossible to harmonize the transnational Open Source system with sovereign systems: both cannot be clearly mapped to each other. Yet, international arbitration provides a type of remedy that already exists in software development, illustrating how a shift from just fighting bugs to mitigating architectural flaws can look like.

Initially, the Internet imitated the institutions of the social world despite their limited eligibility (such as "emails" with their complex and vulnerable architecture). Today, societies are socio-technical without delimitable transitions between technology/Internet and society. Societies have started to adapt to and integrate the possibilities the code provides, no longer vice versa. Sovereign state systems early found their limitations in tackling the resulting challenges. However, software development had already to manage comparable issues. The Java Virtual Machine and Ceph are two of many examples: another abstraction layer can create flexibility, simplification and unification on top of different systems.

International arbitration could offer Open Source a transnational and globally-unified framework, enshrined in an arbitration agreement: embedded in a dedicated organization in an eligible legal system to facilitate the conduct of organizations and communities on which code and the Internet depend.

Open source and its related institutions are already the core element of a transnational separation of powers, which is based upon competition: public processes & public code in conjunction with distribution (of development, code, review & testing) enable forking (to avoid monopolies and irrevocable consolidation of powers at one place). Reflecting the software engineering concept "secure by design", Open Source has created a "socio-technical system secure by design" because it avoids single points of failure both in social and technical realms: it does not relate governance to centralization but to distribution. Indeed, if issues like the 2020 Solarwinds Hack would spread in deployed Linux kernels, this could have unprecedented consequences far beyond the technical realms. However, Open Source and its institutions remain capable of providing sufficient security and deterrence. There is much more behind Open Source than just open/public code.

The increasing use and consolidation of IT in governments may break the traditional separations of powers and does not provide the "security by design" of Open Source institutions if applied to socio-technical systems. Indeed, if one administrator and his password in one consolidated IT department can manipulate the databases used in executive, legislative and judiciary operations, new risks can arise. The system around Open Source already contributes to the security provision of and on the Internet and thus, indirectly to the overall security provision of people and entities that depend on the Internet: it facilitates security in socio-technical societies.

If it proves eligible, enshrining the relevant (and legally implementable) Open Source institutions in an arbitration agreement may result in an compatible abstraction layer on top of the traditional state systems. Complementary, this abstraction layer may facilitate to release traditional systems from tackling issues they simply cannot tackle without softening and blurring their own institutional architecture. It may turn antagonism into symbiosis.

However, Facebook's Libra indicates the complexity (but also the possibility) of creating such "implicit legal" ventures (in Switzerland). It also indicates that Switzerland could possibly enable the fusion of an international arbitration body (through its "international private law") with an open/public/distributed but regulable cryptocurrency to facilitate not just the (Open) Source but also (open) exchange within one globally unified system.

Although they will be critical and challenging for any international arbitration approach, legal patent- and license-related questions are not considered in this lecture.

This lecture is derived from the perspective of the field of international relations. It illustrates the role of Open Source in contemporary security provisions (next to and in interaction with sovereign states' security provisions for citizens) and it aims to put alternative (types of) approaches with and around Open Source into discussion.

Jupyter notebook is a tool that allows Data Scientist to analyse dataset. However, it is not easy to create a custom user interface integrated in an existing application.

Jupyter React, https://github.com/datalayer/jupyter-react, an open-source library, fills that gap and provides components that a developer can easily integrate in any React.js application.

The Jupyter user interface stack is built on top of Lumino, which is an imperative way to build user interface and can not be consumed by industry standard declarative frameworks like React.js.

As a user interface developer, if you want to create a custom data product on top of Jupyter, you have to stick to Lumino and update the existing notebook interface. This is not what you want. You want your toolkit (like React.js) and you want to integrate on a component basis the Jupyter functionality in your application.

eBPF is fastly becoming the first choice for implementing tracing and security-critical applications and software.

Yet, its ecosystem lacks tooling to make developers' life easier.

Join this talk to get to know bpfcov: an open-source tool I wrote that uses the LLVM pass infrastructure to instrument your eBPF programs to collect coverage data while they run in the eBPF VM in the Linux kernel.

I bet we all have heard so much about eBPF in recent years. Isn't it?

Every day we hear about a new project using some eBPF magic underneath.

eBPF programs are written in C but compiled for a specific ISA later executed by the eBPF Virtual Machine.

LLVM has a specific backend allowing us to write C and get eBPF ELF objects out.

Still, there are no tools helping developers to clearly understand which path their code took while running, which branches were uncovered, and maybe why. Even testing the eBPF programs is a pain, given that not all the types of eBPF programs are supported by BPF_PROG_TEST_RUN in the Linux kernel.

Yes, BTF and CO-RE are improving the situation. But, writing eBPF is still mostly about fighting against the BPF VM verifier.

Until today, there is no simple way to visualize how the flow of your eBPF program running in the kernel actually was.

That's why I sat down and wrote bpfcov. A tool to gather source-based coverage info from your eBPF programs.

During this talk, I will show the audience the secrets of the BPF target in LLVM and how I wrote an out-of-tree LLVM pass to instrument eBPF programs with counters, counters expressions, and friends.

The goal is to help eBPF developers to get to know how to use the powerful LLVM infrastructure to make the eBPF ecosystem - and their life - better.

Building cloud-native Java applications is undoubtedly awesome.

However, it comes with undeniable new risks. Next to your own code, you are relying on so many other things.

Blindly depending on open-source libraries and Docker images can form a massive risk for your application.

The wrong package can introduce severe vulnerabilities into your application, exposing your application and your user's data.

Join this talk where we’ll show common threats, vulnerabilities, and misconfiguration including the recently disclosed issues in Log4j.

Most importantly, you’ll learn how to protect your application with actionable remediation and best practices.

Our mobile devices have various apps that need updates from various servers at various intervals. Each app connecting to its own server on its own schedule, perhaps using inefficient technologies, can cause a lot of battery drain. Push Notification services are systems that can route all the important updates our devices need - whether they're instant message, VoIP, or social updates - into one shared channel.

Unfortunately, the status quo in push notification services rely on centralized, proprietary services hosted by a third party. UnifiedPush is a set of free and open source specifications that allow you to get push notifications while picking your own hosting provider. This presentation goes over the history of UnifiedPush, current state of the project and architecture, and what the future goals of UnifiedPush are. It also discusses push notifications on Linux phones.

Authentication is the «‎must-have» feature of every web application. Traditional centralized auth feature has the major disadvantage: if the authenticator is down, it affects on to all related services. In this talk I would like to discuss auth on Ethereum blockchain, go through its major benefits and introduce sample application with the decentralized authentication implemented in Raku.

Authentication module — «must-have» feature of modern web application.

Traditionally the authenticator was integrated right into an application (web1.0). The user had to register and then, using a login (email) and a unique password, enter the personal account, post the comment or download the file. Credentials were stored on the web application server, and the flow of authentication, authorization and identification was managed by some module or service. This the sample of hyper centralized authentication.

Built-in authenticators have been evolved to external third-party authenticators. In the era of global services and social networks (web2.0) the visitors (as well as the site owners) began to delegate authentication to corporations. At the back side of that process we had got the bloom of the phishing sites and an explicit target ads. In addition, there were the clear symptoms of centralization and de-anonymization.

Blockchain (web3.0) has naturally become the third iteration in the evolution of authenticators. On the one hand, this technology provides a truly decentralized and transparent audit platform for the authentication, and on the other hand, it makes the authentication and identification flow much more anonymous.

In this talk I will consider the main benefits of decentralized authentication on the Ethereum blockchain, discuss disadvantages and common attack vectors, talk about the integration tricks and demonstrate and briefly analyze a working example in Raku.

This talk might be of interest to system architects, security software developers, Raku and Ethereum enthusiasts.

ARA Records Ansible playbooks and makes them easier to understand and troubleshoot. The author will explain why he created the project back in 2016 and how it might be useful for a wide range of use cases wherever Ansible runs from. Including a live demo, we'll see how it works under the hood and you can expect to walk away from the presentation with an understanding on how to get started for your own Ansible playbooks within minutes.

ARA Records Ansible playbook results in local (sqlite) or remote (mysql/postgresql) databases with a regular Ansible callback plugin. It provides an API, a reporting interface as well as a CLI to query, search and browse detailed and granular playbook task results for individual hosts. Highlighting simplicity as a feature of the project, this presentation will provide examples that are appropriate for use whether Ansible runs from a laptop or at a large scale in production.

On Mozilla Common Voice, as of December 2021, there are 154 locales, but only 87 fulfilled the requirements to collect voices, where 27 of them are fairly new. In this two-part presentation, we want to give some starting points for the new language communities, share our accumulated knowledge in the last year while working on the under-resourced Turkish language, with initial training results.

The presentation includes the following topics: Resources on Mozilla Common Voice, how to analyze your dataset, how to set goals, how to design a social media campaign, what tools you can use, Google Colabs, Coqui STT, and our roundups on training Common Voice Turkish Dataset v1 - v7.0, all with our successes and failures as Common Voice Turkish Volunteers group as lessons learned.

• Errata: In the video "checkpoint" is mistakenly written/spoken as "breakpoint", these are corrected in the slides.
• Addendum: Our dataset analysis and training results for the Common Voice v8.0 dataset have been added as new slides and video.

Discussion between the Artificial Intelligence panel's speakers.

The Arm Confidential Compute Architecture (CCA) is an extension of the Armv9 architecture designed to provide confidential computing in standardised and scalable way. CCA builds on existing principles built for TrustZone and virtualization to create a scalable and secure solution. CCA places requirements on hardware and firmware, which together provide the trusted computing base for a new class of secure execution environment that we call a Realm. Trusted Firmware is the key community project that provides a reference implementation of open source Secure firmware for Arm-based processors. This talk briefly introduce Arm CCA and illustrate how Arm plans to develop and enable it in the open by leveraging the community effort that drives Trusted Firmware as open-source project.

The entity-component-system pattern (ECS) is popular in game development for its ability to model complex dynamic simulations with mechanical sympathy, in an environment where microseconds matter.

The pattern is focused on run time composition. Entities are mutable sets of component data types, and systems run for entities with specific sets of components. Many ECS frameworks are oriented around components or entities, and systems use run time queries or filters to match their component data requirements against the live state.

In this talk, a system oriented ECS is presented which removes all run time work for systems by storing execution state in the systems themselves. Changing an entity's components leverages Nim's static typing and powerful AST macros to precalculate affected systems and generate pared down system state changes.

The result is statically defined and intrinsically optimised to the user's system/component design, allowing efficient embedded event loops through to complex interactive simulations.

This talk shows the features added to Sparselizard in 2021

GitBuilding is an Open source program for writing hardware documentation. GitBuilding uses your tags and meta-data to automatically generate and insert bills of materials into your documentation. It correctly links different steps to one another (even when you have multiple variants), allowing you to write instructions once and reuse them for multiple projects. It also shows previews of 3D files and lets you easily include links to generated zips and other files in the correct places. You can output the entire documentation in pure Markdown, HTML, or PDF.

Open hardware is beginning to mature. International agencies such as the European Commission and UNESCO see open hardware as key to open access, especially for science hardware. Open hardware could help bring an end to the reproducibility crisis where researchers cannot replicate the work of others. However, open hardware has a key hurdle to overcome: documentation.

Documentation is important for any open project. You can't study and improve something unless it is documented. For hardware the problem is more pronounced, distribution of hardware relies either on people replicating a design themselves, or on a manufacturer producing the design. Without assembly instructions a project can't be used by anyone, for anything but the most simple project, the digital design files are not enough.

As open hardware matures documentation becomes even more important. Most people don't have the time to build all of the products they use. Even those who care about open hardware want to buy a pre-made product. To manufacture a product the documentation must be far more complete, including enough design rationale that a manufacturer can fix problems, and containing not just assembly steps, but also quality assurance procedures.

GitBuilding is a tool designed to allow open hardware designers to keep markdown documentation with their hardware designs, such as in a Git repository. Extra syntax has been introduced to semantically link pages together, and to identify when tools and components are used. This allows the automatic creation of Bills of Materials, as well as reuse of specific instructions for multiple variations of the same project.

GitBuilding was initially designed for the OpenFlexure Microscope (OFM) project. The OFM is an open source laboratory grade motorised microscope that is being trialled for malaria diagnosis in Tanzania. The open project plans to support manufacturers across the world in selling the OFM as an in vitro diagnostic (IVD) device. For this to be possible our documentation must be complete enough that manufacturers can verify the microscopes performance and design, and their own manufacturing of it to a standard acceptable to their IVD regulator. GitBuilding must be powerful enough to support this documentation.

GitBuilding is now needs to generalise. The project needs to be sure it is collecting the correct data for other types of hardware and for other industries. We need to gather input from across the open hardware community, so we know what data needs to be captured, and so where possible this information can be captured exactly one, and used wherever it is needed.

C% (from "C with mods") is an experimental meta-programming language that aims to make coding in C more efficient and fun!

Together with cmod, the reference pre-processor/code generator (written using C% itself), this project enables the C programmer with generic meta-programming constructs such as: parameterized verbatim code snippets, mapping code to static data tables (in TSV or JSON format), multi-pass code evaluation (allowing meta-meta-programming), compile-time command execution (allowing code generation from any other software/language), etc. as well as C-specific constructs such as: function types, named parameters, selection over strings and structs, etc. The C% standard library provides convenience constructs for inclusion in C programs.

Some of the things that C% aims to make achievable are:

• Reusability: Avoid code duplication.
• Consistency: Use the same data across different locations.
• Efficiency: Perform common tasks quick and easy.
• Concision: Write and work with concise code.
• Expressivity: Better express the intent of code.
• Transparency: Hide nothing from the programmer.
• Abstraction: Handle similar things in a uniform manner.
• Extensibility: Easily add new functionality.
• Simplicity: Keep the language simple but powerful.

All while keeping with the spirit of C: trust the programmer and don't prevent the programmer from doing what needs to be done!

Beyond C meta-programming, C%'s generic keywords enable meta-programming in other languages such as Python, Flex/Bison, etc.

For full documentation, please refer to the README.

MariaDB allows fine grained control of access over different database objects. Granting access to a very specific resource is easy. A problem comes up when one wants to grant access to a whole database except for a particular resource (table, column, etc.). The only solution thus far is to grant access to each individual resource and omit the ones that must not be accessible. Clearly this is not maintainable, nor practical.

This is where the DENY command comes in. The gist of the feature: A user will not be able to access denied resources unless the deny is explicitly revoked. MDEV-14443 - Reverse privileges in MariaDB is an ongoing tasks that will implement it. During this talk we will go through use cases, comparison to similar features of other databases well as implementation details of the feature which will (very likely) be part of MariaDB 10.9.

A general overview of porting Linux to mobile phones, with a focus on Qualcomm. From the device tree to how you get started and why you should do it.

Android phones have long been plagued by being based on old versions of the Linux kernel which are seldom patched against vulnerabilities and other security flaws. Additionally being based on old versions which are most of the time not being maintained by anyone anymore a vendor has to evaluate if a given patch applies to the old kernel version they are using or not and modify the patch if necessary. This problem has been somewhat mitigated by closer collaboration between SoC vendors and the Linux kernel community (LTS kernels) but this only applies to drivers and components that are actually present in the main branch of the Linux kernel. Drivers only present in vendor-maintained branches often get left out of security and general bug fixes.

Unfortunately for many companies there isn't a clear financial reason to clean up device drivers and submit them upstream, so in this talk I will give an introduction into how you can get started in making your device run a kernel that's based on mainline Linux.

Running alternative operating systems (other than Android) on your phone is in some cases possible with the kernel provided by the vendor but in these cases you need to rely on solutions like libhybris to work with proprietary user space binaries and libraries to make hardware work. Running 100% open source software while using a vendor-provided kernel ("downstream kernel") is not feasible due to the sheer number of proprietary user space components that would need to be replaced. But with a mainline kernel you can get to a fully free and open source operating system for your phone. And this talk will give you can introduction to some of the basics in getting started with running mainline Linux kernel on your phone and some of the tips and tricks that I have learned over the years.

When you want to see your community grow, running a local event is a great idea. Luckily, many FOSS projects have been down this path, so you won't need to start from scratch. This talk covers the process of running a successful community event, from finding great folks to plan with -- to follow-up for the next event.

When you love your community, you want to see it grow and become stronger. And if you are also lucky enough to have a little extra time and enthusiasm? Well, then it might be time to run an event. Many FOSS projects have been down this path, so you won't need to start from scratch. This talk will cover:

• Setting the scope for your event
• How to find folks to work with
• Creating a plan for success
• Making sure attendees have a great time

Once you have a solid plan in place, running a community event can be very rewarding. Attendees will walk away with a sense of where to start and a strategy for finding the resources they'll need to put on an inspiring community event.

RAUC is a safe and secure open source software solution for A/B updates of embedded Linux devices. RAUC supports industry-leading build system: the Yocto Project and OpenEmbedded, Buildroot and PTXdist. Porting RAUC to a new device requires several advanced technical steps. Layer meta-rauc-community exists to speed up and simplify the integration process for Yocto and OpenEmbedded by providing examples for popular devices such as Rasperry Pi, Allwinner (Sunxi), NVIDIA Tegra and QEMU.

RAUC is a popular solution for A/B updates of embedded Linux devices because of its flexibility, safety and security features. It supports industry-leading build system: Yocto Project and OpenEmbedded, Buildroot and PTXdist. Upgrades are performed through RAUC bundles which can be installed either through the network or just using a USB stick.

To port RAUC to a new device, we need to go through several steps: setup appropriate bootloader like U-Boot, enable SquashFS in the Linux kernel configurations, use ext4 file system, create partitions and configure RAUC slots, generate certificates and setup bootloader environment configurations with a script to switch RAUC slots over upgrades. To simplify the getting started process of developers using RAUC with Yocto and OpenEmbedded in 2020 Leon Anavi created layer meta-rauc-community. In 2021 the layer was moved to the RAUC organization in GitHub. Initially it offered only Raspberry Pi support and over the time, thanks to numerous community contributions, the support was extended to more machines. As of the moment meta-rauc-community provides RAUC sample integrations for Raspberry Pi, Sunxi (Allwinner), QEMUx86 and NVIDIA Jetson TX2.

This presentation will provide a brief introduction to RAUC and will focus on layers meta-rauc and meta-rauc-community. We will go through the exact steps how build, flash and update an image using bitbake to the currently supported platforms. Furthermore we will discuss general guidelines for porting RAUC and adding new supported machines to meta-rauc-community in the future.

The talk is appropriate for anyone with basic knowledge about Linux. It will hopefully help other software developers in the community to overcame faster and easier similar technical difficulties while integrating the RAUC client on embedded Linux devices and hopefully contribute back to the Yocto/OpenEmbedded layer meta-rauc-community.

UX/RT is a new QNX-like OS based on the seL4 microkernel, with improvements in security and reliability over mainstream systems as well as several features they lack, while still maintaining a high degree of compatibility with and comparable performance to existing operating systems. Similar to QNX, UX/RT will be a single-personality Unix-like OS with fast synchronous kernel IPC, a lightweight IPC transport layer, services looked up through the filesystem, and an avoidance of vertical modularity for most subsystems. I will introduce the general architecture of UX/RT and how it differs from existing operating systems, describe a few notable features, and explain why I consider it to be the best balance of practicality, performance, compatibility, and features.

Video presenting the user registration and authentication processes on a Single Page Application towards the i3-Market Platform, using the i3-Market crypto wallet. i3-Market IAM solution is based on Veramo framework and the OpenID Connect standard

Hash join was introduced in MySQL 8.0.18 and was presented for the first time at FOSDEM 2020. Since then, the performance of hash join has been improved, and I will present results that show this. We will also discuss what kind of queries benefit from hash join, what you need to do for hash join to be used, and how to tune your system for optimal hash join performance.

Sometimes good working hardware is obsoleted by missing update support for the operating systems. Using outdated networking software from these systems on today's Internet is a security risk (to the user and the Internet as a whole), and old software might fail altogether (old SSH clients can't connect to modern SSH server, Webbrowser can't load websites using modern transport encryption, TLS).

pkgsrc is a cross-platform package manager maintained by the NetBSD project. With pkgsrc, it is possible to compile and install modern Linux/Unix tools and applications on Unix systems that were abandoned by their makers.

In this talk, I will give my experience, tips and tricks with keeping old Unix systems up-to-date:

• MacOS X PowerPC 10.4 "Tiger"
• MacOS X i686 10.9 "Mavericks"
• Ubuntu 10.04 on ARM (old Linux 2.6.x kernel with special hardware patches that never got upstream)
• Slackware Linux on Pentium 2
• Solaris 9 on SUN Ultra 5

Nextcloud did 3 major releases in 2021, one of which we named "Nextcloud Hub II"because it was such a big step forward for online collaboration. Let's go over what is new!

A short overview: * Nextcloud 21 brought major performance improvements with the High Performance Back-end for Files and other improvements. * Nextcloud 22 brought user-defined groups and workflows, document signing integration, a knowledge base, and many Talk improvements. * Nextcloud 23 or Hub II introduced Nextcloud Office, appointment booking, background blur, permissions and more in Talk, Nextcloud Backup, AIO docker image, and much more.

Join the talk for more details!

Last year in "Go Without Wires" we saw how you can use TinyGo to program code that runs directly on Bluetooth devices.

Now in "Go Further Without Wires" we will see some of the ways that TinyGo can connect to WiFi networks, and consequently to the Internet itself.

This talk will include several actual demonstrations, including a drone.

In this second chapter of the "Wireless Saga", we will get to see how our TinyGo programs can extend out further into the real world, by connecting to Wireless Local Area Networks (WLAN) using several different wireless chips such as the popular ESP-32.

I will talk about how do we proceed when we receive a problematic OOXML document from a customer and show a solution of a sample bug.

oVirt is an open source virtualization solution based on kvm, QEMU and libvirt. Trusted Platform Module (TPM) device support, which brings new security capabilities that modern operating systems utilize or even require, was added to oVirt recently.

In theory, adding TPM support should be as easy as just adding a TPM device to the virtual machine libvirt XML. But features built on top of a lower-level virtualization platform are not always as easy to implement as they may initially seem to be. This talk will present the challenges experienced when adding TPM support to oVirt.

The talk will explain that a supposedly complete feature support in libvirt/QEMU may still require challenging design considerations. What can be used easily in a simple virtual machine running on a desktop computer may not be enough to get the things working well and reliably in a virtual machine management running across many hosts.

Some of the challenges experienced with TPM support have been sorted out while other ones still wait for a good solution. Although focusing on TPM, the lessons presented in this talk can apply to a wide range of features. Whatever we work on, we cannot be just passive consumers of features but we must look for the right ways of using them and be proactive in avoiding pitfalls.

We keep on hearing about the metaverse but what is it and more importantly, can JS be used to build it?

We'll briefly clarify what the metaverse is and give practical examples today with federated virtual reality servers managed by different persons.

Behind the buzzword from Facebook/Meta there is a truly interesting concept : connecting virtual worlds!

To do so there is no need to be one of the largest advertising company. In fact there are several solutions working today allowing to navigate from 3D or VR web pages and even keep information across, like a profile. During this presentation we will explore the WebXR specifications, in particular links between pages, and test an implementation running today named ImmersSpace based on Mozilla Hubs and ActivityPub.

A lot of UX practitioners don't talk to users on a regular basis, at Penpot we might be on the opposite side of the spectrum. We gather a lot of feedback from our users. What for? Fixing (bugs), improving (enhancements), discovering (new needs), prioritizing (asking/frequent queries as an indicator). And the most important thing is what do we do with that feedback and which kind of feedback would we like to receive?

At Penpot, we work as a full support team. We think of our users as a knowledgeable open space they provide us and we all work to learn from the market. Also it’s important to mention that we design Penpot with Penpot, the team members are users too. Plus we manage all our work at Penpot with our sibling Taiga, a powerful agile project management tool which is our sibling company. Obviously we have our own product development vision, but we like to discover what our users think with an open- feedback policy, and feel validation with conducted tests. Our community is the most important and fundamental part in Penpot’s roadmap.

Good questions lead to better answers.

Asking good questions is a must have skill for software developers, especially if you are involved in open source projects. The problem with poor questions is clear when the person answering starts explaining what you already know or what you think isn't relevant. Or they might go ahead and assume that you know a lot and you end up being confused.

In this talk, Navendu walks through his experience as an open source contributor and a maintainer and how he was able to improve this skill and how it has benefitted him.

This quick session is for junior and senior developers alike and offers real examples and takeaways that you can start implementing right away.

During the pandemic we have experienced a sudden growth of remote activities, with people working and studying from home. Most proprietary solutions were not suited for the task, as they were not compliant with GDPR, as they were profiling users beyond the provided service, and in many cases could not guarantee that end user data were maintained within Europe acconrding to EU legislations. Unfortunately, EU governments ignored the situation and signed contracts with big techs for remote work and remote teaching, exposing the personal information of million of EU citizens - the majority of them being students - to unauthorized practices. OSS could be the answer, but was ignored because there wasn't enough time to deploy appropriate solutions. The talk tries to provide a different perspective.

Compilers play a crucial role in hardening software against security attacks. As compiler engineers we experience an increase in demand for security-related features: we simply work on security-related features more often. We find it tough to analyze whether the hardenings we implement are easy or hard to circumvent by attackers. After chatting about this with many compiler developers, our experience is that most feel their work would benefit from a deeper understanding of attacks and hardening techniques. After having looked around, we didn't find much educational material that gives a broad overview, covering all aspects compiler developers ought to know about. Therefore, we recently started an open source book titled "Low Level Software Security for Compiler developers" at https://github.com/llsoftsec/llsoftsecbook/. It aims to improve the industry-wide knowledge about security hardening in compilers and related tools; ultimately leading to more innovation and better implementations of security features. In this presentation, we'll explain the rationale for this new open source project in more detail. We will discuss what content we have so far and what content we plan to add. The project very much welcomes new contributors: we need more new content, more review of content, discussion of ideas for how to make the book better, improvement in the design and layout of the produced HTML and PDF output, etc. We hope this presentation will reach both anyone interested in learning more about low-level software security and anyone interested in helping to grow this project further.

Digital and technical literacies are an ubiquitous requirement in modern research teams. Despite being fundamental, they are rarely part of the curriculum in universities, thus undergrad and early career researchers often struggle to code data analysis pipelines and to automate data collection from experimental setups. Neurosciences, in particular, relies a lot on these skills, with behavioural experiments planning, design of the testing boxes, data visualisation and analysis. To Successfully complete these tasks, researchers need to acquire a significant level of skill in programming and hardware design. To address these problems, we are developing a flexible open hardware platform to lower the barrier in creating experimental setups: BeeHive. It consists of a main board, which nests an ESP32 microcontroller, and several dedicated “daughter boards”, each designed to perform one function (e.g. one board senses temperature, another controls motors, etc). These boards are connected to one another using a standard system already used by other Open Hardware systems, so that there is no need to reinvent the wheel. We can then focus on developing things that are not available yet. The system runs MicroPython, which is a Python derivative for microcontrollers. This architecture allows users to be in control of everything that the platform is doing while also providing plenty of room for completely new applications. Modular structure helps users to get familiar with electronic components already at entry-level expertise while Python is employed for its strong points such as simplicity and widespread usage. In this presentation we set out to explore the core concept of Beehive, describe existing and possible applications.

Many developers don’t think about the JVM level when creating applications. It is something that just simply works. Now more applications are becoming cloud-native and we have JVM’s running in every microservice container, each performance gain can have massive benefits when scaled up. Some tweaks are very easy to implement and can have huge impacts on start-up time and performance of your applications. This talk will go through all the different JVM options and give you some easy and simple advice on how to get the most out of your JVM to save not only money but also energy on the cloud.

Short break.

CadQuery is a Python module for building parametric 3D CAD models in boundary representation (B-rep). It has an active community that has created editors, personal projects, research projects, examples for new and advanced users, and plugins that extend the functionality of CadQuery. The project is maintained by a small core team and numerous community members. CadQuery is built on the OpenCASCADE (OCCT) CAD kernel, and has support for 2D and 3D primitives, allows 3D assemblies and 2D sketches to be created with constraints, and makes heavy use of features like selectors to help capture design intent.

There are multiple editors available for CadQuery including CQ-editor (desktop application), Jupyter-CadQuery (web based), and CadHub (web based CodeCAD sharing platform). There are repositories dedicated to examples and plugins, as well as separate projects for generating sprockets, chains, fasteners, polyhedra, and complex curves. Community members are responsible for much of the content in these repositories. There are also projects that rely on CadQuery, including in fusion research (Paramak), electrical component 3D model generation (KiCAD), and a more mouse-driven CAD application called Semblage. There are several ways of connecting with the community, including Discord, Matrix, Google Group and GitHub. Please introduce yourself and connect with other CadQuery users.

The Raku ecosystem is growing at an impressive rate. The Raku Programming Language allows developers to specify the exact version of a module that is needed in production. This is a very good thing, and makes sysadmins all over the world pretty happy, as they know they can install new versions of modules without fear of breaking production code.

However, developers can also remove distributions from the ecosystem. This presentation describes efforts to make sure that this will never become a problem for production.

qbe is an optimizing compiler backend which consumes programs in a simple intermediate language, optimizes them, and emits assembly for x86_64, aarch64, or riscv64, aiming to achieve "70% of the performance" of advanced compilers like LLVM in "10% of the code". This talk will briefly introduce qbe and its intermediate language, explain how it works and what it's capable of, and go over some sample programs which can be written in it.

Maintaining software systems for a long time is hard. Backporting kernel patches is a complex and expensive overhead. The Linux project's position is - quite rightly - to instruct down-streams to upgrade to the latest release.

In practice, upgrading is difficult, scary and sometimes avoided. It takes time and effort before there is enough confidence that new releases will work in context: full system testing in embedded environments can be arduous. What if we could have continuous, automated full system tests, from from UI, to OS, to kernel, on hardware?

This talk will provide an overview of how this can be achieved with a combination of OpenQA, LAVA and Continuous Integration pipelines. The talk will cover: - How the same tests can be used in both kernel space and user space testing - How the same tests can run in both virtualisation (with OpenQA and QEMU, developed originally for GNOME-OS) and also on hardware - How images are then deployed and tested in hardware (LAVA triggers OpenQA via VNC to begin testing on boards)

Short overview of how Searchfox works, how to use it on other projects (like Igalia is doing with https://webkit-search.igalia.com), planned improvements, and how to contribute to it.

Many say: Galera or Master/Slave replication. What about Galera AND Master/Slave Replication? In this presentation we look at different scenarios where it makes sense to use both technologies together...

Operating Systems (OSes) have historically been classified according to their isolation properties: monolithic OSes, microkernels, single-address-space OSes, or unikernels... Decades of experience in research and industry showed that there is no silver bullet and that different use-cases might demand different approaches to optimize safety and performance.

What if we tried to design an operating system able to be easily reconfigured into any of these points in the OS design space? What if the OS could be a microkernel, a unikernel, or a monolithic OS, at will, and using a wide range of hardware- and software-backed isolation mechanisms?

In this talk, we will present FlexOS, the result of our recent research work in trying to answer this question. FlexOS is an OS allowing users to easily specialize the safety and isolation strategy of an OS at compilation/deployment time, instead of design time. Depending on the configuration, the same FlexOS code can mimic a microkernel with multiple address-spaces, a single-address-space OS with Intel MPK compartments, or many other OS isolation approaches. We have implemented a prototype of FlexOS on top of Unikraft, a popular library OS framework.

Discussion between the Open Hardware panel's speakers..

Progressive Web Apps are web applications that have been designed, so they are capable, reliable, and installable. These three pillars transform them into an experience that feels like a platform-specific application. The central core components that ensure that PWA works flawlessly are Service Workers. These components are a network proxy that takes control of a network request from the application and adds cache capabilities, background app sync, push notifications, and offline features. In this talk, I will review the PWA capabilities in Flutter and show you how you can extend these functionalities to have a better progressive web app building with Flutter in order to boost user experience in your application

The number of devices on which users cannot run Free Software is exponentially increasing. The consequence is an increased loss of control over users’ technology. In order to remediate this situation, the FSFE has been working with the concept of Device Neutrality, understood as a policy principle that ensures users equal access and non-discriminatory use of their devices. The FSFE has advocated for four main principles: stricter consent rules for pre-installed apps, no vendor lock-in, full interoperability, and real-time data portability. The talk will explain the concepts and the challenges ahead.

While digital devices are a ubiquitous reality in all aspects of life, control over the hardware and software running on them is increasingly being limited by internet platforms, digital services providers, hardware manufacturers, and vendors. Several policy and legal concepts have been developed by the academic sector in cooperation with regulatory bodies and courts to tackle this issue in the EU.

The whole debate boiled down to principles that have been included in the EU's major overhaul of internet law: the Digital Markets Act. Device neutrality is a policy term that translates as non-discrimination of services and apps by providers, manufacturers, and vendors. The objective of device neutrality is to enable consumers to bypass gatekeepers and enable a fair and non-discriminatory use of Free Software.

The talk will explain the four main demands the FSFE has been leveraging in the public debates and legislative processes: * Strict end-user consent for pre-installed apps; * No vendor lock-in; * Interoperability of services based on Open Standards * Real-time data portability

At least since the final Multics report in 1977, researchers identified the ability to isolate kernel subsystems as a critical mechanism for increasing the reliability and security of the kernel. Unfortunately, despite many attempts to introduce isolation to the kernel, modern systems remain monolithic. Historically, software and hardware mechanisms introduce a prohibitively high overhead for the isolation of subsystems with the tightest performance budgets. Today, however, the balance of isolation and performance is starting to change with the development of Rust, arguably, the first practical programming language that achieves safety without garbage collection.

RedLeaf is a new operating system developed from scratch in Rust with the goal to explore the impact of language safety on operating system organization, and specifically on the ability to utilize fine-grained isolation and its benefits in the kernel. In contrast to commodity systems, RedLeaf does not rely on hardware address spaces for isolation and instead uses only type and memory safety of the Rust language. Departure from costly hardware isolation mechanisms allows us to explore the design space of systems that embrace lightweight fine-grained isolation of kernel subsystems. We develop a new abstraction of a language-based isolation domain that implements a unit of information hiding and isolation of faults. Domains can be dynamically loaded and cleanly terminated. Building on RedLeaf isolation mechanisms, we demonstrate the possibility to implement end-to-end zero-copy, fault isolation, and transparent recovery of device drivers.

To evaluate the practicality of RedLeaf abstractions, we implemented a subset of the POSIX interface as a collection of RedLeaf domains. RedLeaf's isolation mechanisms allow us to support the transparent recovery of device drivers. To demonstrate that Rust and fine-grained isolation introduce a practically-acceptable overhead, we develop efficient versions of 10Gbps network and PCIe-attached solid state-disk NVMe device drivers that match the performance of carefully-optimized kernel-bypass device drivers used in modern network and storage processing frameworks.

(With a $4 microcontroller to build fun, accessible, and unique forms of interaction)

The magic of computers and smartphones is the fact that they provide a very malleable interface - the screen. Without having to manufacture extra parts for every new application, this is a massive time and cost saving for engineers. However, this comes at a cost of accessibility and usability, as well as diminishing the physical connection one might have to the device they are using. Physical interfaces are now much easier to develop, and can even be constructed by the end user, since MCUs are now very cheap and readily available, along with lots of modular parts to construct interfaces with. Web Serial provides the added benefit of being able to use the highly distributed and easy to code with JavaScript / Web platform with these MCUs. This means rapid prototyping can be performed, along with user testing, very easily, making it much cheaper and faster to reach an end product. This talk intends to demonstrate some basic examples along with some steps to getting a process together yourself.

• Introduction to Web Serial API
• An overview of the MCU market today
• Demonstrations of some homemade physical interfaces for web applications
• How to set up a basic web app using web serial
• Overview of reading values from a physical input component through a circuit and converting it to serial data
• Using browser-based circuit design tools for safe pre-breadboard experimentation using Wokwi and CircuitJS
• Building a simple physical input, through to reading the data into the web application
• Ideas for potential tangible user interfaces, summary, questions.

This talk presents OpenNebula's new distributed Edge Cloud Architecture, which is composed of Edge Clusters that can run any workload (both Virtual Machines and application containers), on any resource (bare-metal or virtualized), anywhere (on-prem and on a cloud/edge provider). An Edge Cluster, built on open source technologies that already exist in the Linux operating system, is a hyperconverged functional set of managed objects that include storage, network, and host resources. An Edge Cluster provides all the resources needed to run virtualized or containerized applications. OpenNebula’s management services, including scheduling, monitoring and life-cycle management, run in the cloud Front-end and orchestrate from there the local or remote Edge Clusters. The Front-end also provides access to the administration tools, user interfaces, and API. Although the requirements may vary depending on the number and size of the clusters and API load, the Front-end node only requires 8 GB of main memory and 4 cores. The Edge Cloud Architecture is able to provide a lightweight and easy-to-use storage platform for medium-sized clusters consisting of tens of nodes. OpenNebula’s Edge Cloud Architecture is able to manage hundreds of these clusters, as they operate autonomously in terms of networking and storage, and handle thousands of virtualized hosts and tens of thousands of virtualized applications. In this presentation we will explain in detail the deployment model for Edge Clusters, the specialized storage solution they incorporate (OneStor), and the performance benefits of this multi-cloud architecture as confirmed by the latest benchmarks.

Building OpenOffice is not an easy task. The purpose of this presentation is to show how it is possible to leverage virtual machines and containers to: 1- make this task easier and as much automatic as possible, 2- avoid filling our computers with packages and libraries we may never need otherwise, 3- build different releases (trunk, 4.1.x), for different operating systems, on the same computer.

The CrowdSec project aims at providing a crowdsourced approach to common infrastructure defense problems, by distributing free & open-source software allowing to protect yourself and share information about malevolent actors. These software components, of which Crowdsec is the main piece, work by processing logs and enriching them, to apply behaviour-based scenarios (heuristics) that will identify attacks pattern. One of the core concepts of Crowdsec is to separate the detection of an attack and its reaction, to be suitable for modern architectures. While Crowdsec is in charge of the detection, the reaction is performed by "bouncers" that aim to be deployable at any level of the applicative / infrastructure stack.

The CrowdSec project aims at providing a crowdsourced approach to common infrastructure defence problems, by distributing free & open-source software allowing you to protect yourself and share information about malevolent actors. These software components, of which Crowdsec is the main piece, work by processing logs (or more generally information stream) and enriching them, to apply behaviour-based scenarios (heuristics) that will identify attacks pattern.

One of the core concepts of Crowdsec is to decorrelate the detection of an attack and its reaction, to be suitable for modern architectures. While Crowdsec is in charge of the detection, the reaction is performed by "bouncers" that aim to be deployable at any level of the applicative / infrastructure stack :  - as a nftables/iptables daemon "a la fail2ban"  - as a nginx plugin  - as a wordpress plugin - a kubernetes ingress controller  - etc.

We hope that this approach, combined with a declarative configuration and a stateless behaviour, will make it an ideal candidate to enhance the security of modern stacks (containers, k8s, serverless and more generally automatically deployed infrastructures). We are committed to building a strong community, with all that it implies :  - a public hub to find, share and amend parsers, scenarios and bouncers. - permissive open-source licence to stay business-friendly

and overall a strong commitment to transparency and community-first mentality, by tooling and behaviour

Software has become increasingly central to scientific research. Both software development and its use are essential activities for scientific teams. But investment in its production, maintenance, and adoption is often overlooked, and academia often fails to leverage best practices for software engineering from industry, the open source community, or elsewhere. Furthermore, investment in the user experience (UX) and usability of scientific software is largely an afterthought, if considered at all. As such, any future investment in UX is expected to have a disproportionately positive impact on adoption of scientific tools (i.e. broadening access) and on scientific discovery itself. Currently, the impact of this kind of investment (or lack thereof) is largely unknown.

Scientific software stands to benefit from the learnings and current practices in open source design. This talk will explore the unique workflows and incentives of research institutions (and other contexts in which scientific software is produced) and map them to current practices of open source design with the intention of bringing to light the opportunities to better understand how and when to invest in the UX of research software, how to grow expertise in UX, and how to cultivate norms on peer-production platforms toward good UX practices.

Flatcar Container Linux is a minimal base OS to run containers. As a friendly fork of CoreOS Container Linux it continues the project under a new name. The main features are the A/B partitions for automatic updates and rollbacks, and the integration of Ignition for declarative configuration on first boot. Declarative configuration is a key element for managing machines following the principle of Immutable Infrastructure, but causes friction if it means that the whole machine has to be reprovisioned for configuration changes. With Ansible instead of Ignition for the configuration management we can find a compromise by giving up on avoiding configuration drift due to leftovers of old configurations and their side effects. Out of this experience the idea was born to rerun Ignition on configuration changes. While the big hammer method is to reformat the filesystem and losing application data, a more fine-grained solution could exist by clearing only parts of the filesystem. This talk shows how to use Flatcar Container Linux with Terraform, Ignition, and Ansible, and ends with a proof-of-concept demo for Flatcar Container Linux to allow configuration changes through Ignition while avoiding configuration drift.

ProxySQL has proven itself as the de-facto standard reverse proxy for MySQL, yet, we are always looking for new features and improvements. During this past year starting with v2.1.0, four new major ProxySQL versions were released, and with them new features of all sorts were introduced, ranging from protocol changes, authentication improvements, clustering improvements, new monitoring features (for Galera, Group Replication, Aurora AWS) to DDOS protection. Join us for a deeper dive on the details of these (and more) new features, what they have to offer and how you can get the most out of them.

The talk will cover the design of very complex and powerful OSHW Linux boards based on the new NXP iMX8 and ST STMP1 SOC with FLOSS KiCAD tools and then running FLOSS software for cloud, IoT and Health to offer full transparency to the people who value their privacy not only on software but also on hardware level.

The talk will cover the design of very complex and powerful OSHW Linux boards based on the new NXP iMX8 and ST STMP1 SOC with FLOSS KiCAD tools and then running FLOSS software for cloud, IoT and Health to offer full transparency to the people who value their privacy not only on software but also on hardware level.

Clang and LLVM have a great history of supporting a great variety of CPUs, from 8- to 64-bits assuming they all have a smallest size of an addressable unit of 8-bits words. Despite the fact that a lot of types and there alignment can be defined with the “target datalayout” string, the “character” and “short” type have been hard-coded into clang and llvm.

Clang and LLVM have a great history of supporting a great variety of CPUs, from 8- to 64-bits assuming they all have a smallest size of an addressable unit of 8-bits words. Despite the fact that a lot of types and there alignment can be defined with the “target datalayout” string, the “character” and “short” type have been hard-coded into clang and llvm. Once you compile with clang you will get for example:

@.str = private unnamed_addr constant [6 x i8] c"Hallo\00", align 8

Some proposals exist to that offer a solutions to this problem (e.g. FOSDEM 2012: “Adding 16-bit Character Support in LLVM” or https://lists.llvm.org/pipermail/llvm-dev/2019-May/132080.html: “On removing magic numbers assuming 8-bit bytes”). Following this ideas one has to apply changes to over 120 files (clang and llvm v12.0.0) and keeping a patch set nearly impossible.

Looking for simpler solution for this problem we explored a couple of alternative solutions. Two design goals have to be satisfied:

don’t change CHAR_BIT
keep CharWidth at 8-bits

Only the modification of the character alignment to 64-bits is allowed. With modifying only 8 files (some of them only dealing with character assertions) we end up with the desired result of:

@.str = private unnamed_addr constant [6 x i64] [i64 72, i64 97, i64 108, i64 108, i64 111, i64 0], align 8

This solutions can also easily be adopted to machines with a minimal addressable unit of 16- or 32-bits. Also “WChar” can be addressed with minimal changes.

As this is solution is still under testing, the amount of files changed might be further reduced, and should allow for a small and simple patch set.

In 2021, a tender financed by the Australian Government has been won. The purpose of the project was to create a lecture book for kids, parents and their teachers who have a European (Hungarian) background, and who want to keep their cultural heritage, while they are living in a non-Hungarian speaking country.

Such a project has a lot of interesting challenges but in this talk, mostly the technical aspects will be introduced. The perspective and the journey of the editor of the book will be demonstrated, whose responsibility was to combine the chapters written by three different authors into a single, ready-to-print document.

The main tools were LibreOffice Writer and Draw but GIMP and InkScape also played a significant role.

In the talk, various tricks and steps will be shown how the document has been created and how the different tools were able to cooperate. Besides the working ways, some non-working paths and traps also will be shown.

Enu is a 3D live coding environment that can be used for education, exploration, and light game development. It uses a simple, logo-style Nim DSL, and aims to be accessible to as many people as possible, even those who may not yet be able to read or type. It's still fairly immature, but will eventually be suitable for implementing simple multiplayer 3D games.

In this presentation, Enu's creator will walk through creating a simple 3D game with his 6 year old son using Enu 0.2.

Why build #4 on the Green500 using OpenStack? It makes it easier to manage. Cambridge University started using OpenStack in 2015. Since mid 2020, all new hardware is controlled using OpenStack. Compute nodes, GPU nodes, Lustre nodes, Ceph nodes, almost everything. OpenStack allows large baremetal slurm clusters and dedicated TRE (trusted research environments) to share the same images. Is this a cloud native supercomputer?

We will explore how OpenStack is used to manage a supercomputer as a shared pool of hardware resources, that can be partitioned between a multitude of different platforms required by a diverse group of scientists. Ranging from Trusted Research Environments (TREs), on demand dedicated AI platforms, dedicated big data platforms, and to traditional shared Slurm clusters.

We will focus on providing a range of services from a single shared hardware pool, allowing for the delivery of both on demand interactive compute platforms for STFC's IRIS e-Infrastrcture and Slurm clusters such as the #4 in the Green500, called Wilkes-3: https://www.top500.org/system/179930/

This makes use of both OpenStack Ironic, for the baremetal deployment, and on-demand OpenStack KVM powered VMs running Cluster API provisioned Kubernetes, with KubeApps to deploy JuypterHub.

InterPlanetary Wheels (IPWHL) are platform-unique, singly-versioned Python built distributions backed by IPFS for security and reproducibility. Using the peer-to-peer file system IPFS, the distributions have the advantage of being easily replicated and not having a single point of failure, thus are more resilient. While this project targets at Python package in particular, the idea can be similarly applied to other software distributions such as Linux distributions.

Machine learning models have made it to the browser. Virtual backgrounds and background blurs are everywhere! Many recent developments including Tensorflow WASM backend, smaller ML models, pre-trained model repositories have enabled widely used virtual backgrounds and backgrounds blurs.

This talk will explore how a simple background blur works, how developers can code their own blur for a WebRTC call, and most interestingly - what other ML/AI applications can be built using the same framework

Machine learning models and inferences are being run on the browser and have become very performant. Libraries and frameworks like mediapipe, bodypix have made it easy to integrate ML-based experiences into a WebRTC call with relative ease. We're still in the early days of discovering their possibilities in web applications.

In this talk, we will walk through how Daily integrated mediapipe in its WebRTC library. We will explore:

1. How segmentation models, like the ones used blur backgrounds, work.
2. How one can integrate an ML segmentation library (like mediapipe) in a WebRTC video call.
3. What other sorts of custom video applications and experiences one can build using a tech stack like these.

Hopefully, this leaves the audience with ideas for writing custom video processors that might enable the next generation of video experiences on WebRTC.

In this talk, I will show you how to build and deploy ply (a dynamic tracing language for eBPF) to a BeagleBone Black then write ply scripts to attach probes and tracepoints to a running kernel and application on that same target. eBPF has rapidly eclipsed all previous tracers for Linux. While eBPF has taken the cloud native community by storm, the technology has yet to make significant inroads within the embedded Linux ecosystem. I will explain the reasons for this current situation and demonstrate a possible way forward.

The bpftrace dynamic tracing language relies on the LLVM-based BCC toolchain to compile scripts down to eBPF bytecode. Because of its dependency on LLVM, BCC only supports a few 64-bit CPU architectures, severely limiting the use of eBPF in embedded systems. Fortunately, the IO Visor Project offers a lightweight alternative to bpftrace called ply. Like bpftrace, ply’s syntax is inspired by both DTrace and awk. Unlike bpftrace, ply targets embedded CPU architectures like ARM and PowerPC making it possible to deploy eBPF to many more devices. Buildroot includes ply as of its 2021.02 LTS release.

Using the new Holochain Rapid Application Development tools, we'll scaffold a Holochain application from scratch, generating all the necessary boilerplate, code and types for your specific use case.

You'll learn how to use the RAD tools yourself, and what are the next steps you can follow to start developing a hApp.

The Go regexp package is an extremely competent piece of engineering, with attractive features such as being guaranteed to run in time linear in the size of the input. However, it can be made to go faster.

This talk will describe:

• how Go regexp works
• five changes that improve regexp performance
• the basic profiling techniques used to identify these optimisations
• further opportunities for optimisation, including via Generics.

In chronobiology and sleep science, researchers often collect data using research-grade activity trackers called actigraphs, which measure movement and determine rest-activity cycles, and light dosimeters, which measure light exposure. At present, there is no meta-data standard for actigraphy and light exposure data that describe aspects of the data collection, such as device manufacturer, sampling rate, or instructions given to the participant. However, meta-data like those are critical for aggregating data and comparing data collected in different samples or across various research sites. Over the past 1+ year, we have been working on developing a consensus meta-data standard for describing actigraphy and light exposure data. The standard is written in JSON-schema, and is extendable to other time-series modalities (such as temperature). The standard is the joint effort of two teams of researchers volunteering their time. In this talk, I will describe the journey from inception to standard, along with the challenges and barriers encountered.

The increased need for secure firmware of all kinds in "IoT" devices from simple sensors to SBC's capable of running large operating systems (eg: Pis, IMXx boards etc) is well known and being driven by many forces, eg: Industry 4.0, 5G, 6G etc. What interestingly is missing is how this firmware provides additional security beyond that of the individual device: to the system as a whole, supply-chain provenance and applications; then further on to how we deal with security incidents through the added forensics and analysis of these devices. Finally we reach the impact of secure firmware to safety-critical systems. Trusted computing, TPM and remote attestation are all well known, but their integration between themselves and the systems they are part of are going to be critical.

In this talk we will set out how secure and high-integraty aspects of systems will or should be reflected in the development of firmware for a wide-range of devices.

Trusted computing, remote attestation and the unbiquitous TPM (not forgetting Pluton and friends) are all well known technologies. Indeed a trusted computing base requires firmware with specific capabilies that promote certain aspects of immutability, identity and integrity measurements - if these properties are provides then we have the start of a chain of trust and a measurement and identity mechanism that allows that device to be "attestable". The further property of being "trustable" needs more explanation but refers to the core root of trust measurement and how this is established, amongst other requirements.

Once we have a collection of attestable (and trustable) devices then remote attestation offers us the possibility of trust relationships between those devices leading to higher-level trust capabilities and integration with supply-chain and forensics.

To further demonstrate this we have developed case studies from the medical and railway verticals based upon edge cloud and 5G communications. As part of this talk we will use these safety-critical domains as the drivers for a wider and more integrated trusted computing base and ultimately the requiremnts towards firmware and hardware that sits at the core of this.

Optimizing MariaDB performance and troubleshooting MariaDB problems are two of the most critical and challenging tasks for DBA’s. The databases powering your applications need to be able to handle heavy traffic loads while remaining responsive and stable so that you can deliver an excellent user experience. Further, DBA’s are also expected to find cost-efficient means of solving these issues. In this presentation, we will discuss how you can optimize and troubleshoot MariaDB performance. We will look at specific, common MariaDB problems and review the ten tips that allow you to diagnose and resolve them.

Some languages offer a very simple syntax for testing via assertion statements, for example with an assert function that creates a simple test that passes if given a true value and fails for anything else. This style of testing is admirably concise, but can lead to cryptic test messages that make it very difficult to determine what a test was attempting to check without opening up the file containing the failing test. At the other extreme, it's possible to write very expressive tests with a fluent, method-chaining API. For example, using the Chai.js assertion library, a test might read beverages.should.have.property('tea').with.lengthOf(3). This allows tests to automatically generate much more useful messages but comes at the cost of creating a fairly complex test API with many new methods to learn.

Raku's core Test module falls somewhere between these two extremes – it offers an API with a handful of functions that's easier to learn than a full fluent API but more expressive than simple assert statements. This is a sensible compromise.

But I claim (assert?) that, with a bit of metaprogramming trickery, Raku lets us have the best of both worlds: we can have a zero-learning-curve test API that's just as simple as assert statements while also being just as expressive as a long chain of method calls in a fluent style. I'll present this style of testing, discuss its use in Raku, and consider ways in which Raku lets us improve on the status quo.

The pgeu-system is an integrated system for managing conferences. Originally developed for Postgresql Europe's own conferences, the system has grown into a generic system for managing events, visitors, speakers, sponsors, and volunteers. It integrates the functions such as call-for-papers, managing schedules, invoicing, accounting, and more.

In this talk we will do a whirlwind tour of the tool, from the context of the foss-north conference.

The modern web has viewers for all sorts of formats that can be loaded in the web browser, except for other web sites. The 'Save Page As' feature doesn't really work for most modern web pages. This talk will briefly cover the work of the Webrecorder project, from creating a new web archiving format to browser extensions and viewers, in making archiving and preserving the modern web more accessible to all!

Hardware and container virtualisations are the fundamental technologies of modern cloud stacks. While these technologies virtualise different layers of software and hardware, they have one common thing: they are quite inefficient in terms of communication between isolated entities. The isolation relies on MMU and involves a privileged intermediary, which leads to heavy transitions or sharing data at the page granularity. The escape from this trap we see in the hardware capabilities introduced in CHERI. The CHERI architecture efficiently combines hardware memory capabilities with conventional MMU architectures. It gives not only safety to memory pointers, but also provides lightweight isolation mechanisms.

In this talk, I will present Introvisor, a lightweight hypervisor for microservices. It uses CHERI capabilities for isolation and data sharing, does not require software porting thus compatible with existing software, and provides strong security guarantees.

Hardware acceleration has become prevalent in most application domains as a means to increase performance, while also achieving high energy efficiency. However, the programming models for heterogeneous hardware accelerators inherently support C/C++, thereby hindering the exploitation of heterogeneous resources from managed languages, such as Java. In the University of Manchester, we have been developing TornadoVM; an open-source software technology that can be used as a plugin to OpenJDK and other JVM distributions to enable hardware acceleration in a programmer friendly manner.

In this talk, we will present a practical view of TornadoVM and focus on two parts: (i) analyze what can impact the performance of applications on heterogeneous co-processors, and (ii) how Java developers can utilize TornadoVM to increase the performance of their applications.

https://github.com/beehive-lab/TornadoVM

Most Kobo/Tolino readers offer a well marked console port and often a second UART. If they are not water resistant, they offer an internal µSD card slot containing the whole operating system and bootloader so that sounds like an invitation to do something interesting with them besides just reading books. Especially in prolonged outdoor activities, the display and their low power consumption have their merits. Hardware is quite similar, so you also have chances to get a replacement next corner. Several devicetrees and also some drivers made their way into mainline linux now, on others upstreaming work is in progress. Support is starting to find its way into mobile linux distributions like postmarketOS and graphics start to work with standard APIs. In this talk I talk about my experiences, especially the current state of support in mainline linux, what is missing and what are the challenges. I will also talk about requirements for the graphics userspace and shortly present my favorite use case: displaying maps.

Modern plant breeding research requires a large amount of data to function effectively. Data repositories are improving in their ability to store this data, but there is a growing need for interoperability between disparate data sources and applications. The Breeding Application Programming Interface (BrAPI) project offers a solution to this problem with a standardized RESTful web service API specification. This specification provides a standard data model for the plant breeding domain, plus a well-defined set of methods for interacting with the data. The goal of the project is to promote interoperability, data sharing, and open source code sharing across organizations who produce and consume data in this domain. The BrAPI project is a community built project and that community is well established and continuously growing. The standard is built based on concrete use cases to solve real interoperability challenges faced by the community. Beyond the core standard, the community has built a variety of open source tools and resources to help build and test implementations of the specification. The community is also constantly producing new BrAPI compliant applications, analysis tools, and visualizations that will work with any BrAPI data source.

In this presentation, Mike Conley walks you through the same onboarding process that new Firefox desktop developers go through to get familiarized with the project. Want to know what Firefox's relationship with Gecko is? What's the relationship between the Firefox and Thunderbird codebases? What does Firefox code even look like? Find out this and more!

The organizers of the Legal and Policy DevRoom for FOSDEM 2022 discuss together the issues they've seen over the last year in FOSS, and consider what we can learn from the presentations on the track this year, and look forward together about the future of FOSS policy.

The organizers of the Legal and Policy DevRoom for FOSDEM 2022 discuss together the issues they've seen over the last year in FOSS, and consider what we can learn from the presentations on the track this year, and look forward together about the future of FOSS policy.

I want to explain how to build data-intensive Jamstack apps with outstanding performance, low costs, and scalability while having great developer experience.

It's been 15 years since the quote “Data is the new oil” was coined, and Jamstack is here for more than 6 years already. Yet, there's no straightforward way to build a data-intensive app with outstanding performance, low costs, and scalability while having great developer experience. Oh, really? In this talk, I'll show how you can build a lightning-fast Jamstack app that works with massive loads of data with open-source tools and having lots of fun.

One of the tasks of my job is to create corporate templates. It is really important to spend the right amount of time on them, since they are the image of the entity (whatever kind of) to the public, and they usually last for decades. Knowing well the needs and requirements is possible to automate a lot of things, still without macros. But pushing so much Writer to its limits let us discover some minor bug or possible enhancements.

Most Linux distributions are not designed to support desktop virtualization, and GPU vendors have failed to agree on a common way to let virtual machines access 3D capabilities (SR-IOV; vfio-pci; vfio-mdev or virtio-gpu...). The result is that it is still complicated to create fast and responsive virtual machines locally.

Phyllome OS is a Fedora Remix based on Fedora Server which attempts to make it easier to run virtual machines locally on computers that support hardware-assisted virtualization, using mostly paravirtualization (aka virtio-devices). It currently relies on existing technologies (libvirt; KVM/QEMU; virt-manager; GNOME Shell; etc), but will eventually implement its own virtual machine manager, package the cloud hypervisor as an alternative to QEMU, and use filesystem-level encryption to protect virtual machines disks. The main idea behind this OS is to treat the host, Phyllome OS, as a read-only system, i.e. as a mere appliance to host virtual machines. The presentation will give a demonstration of Phyllome OS in its current state.

Despite steady progress, especially on the KVM/QEMU front, desktop virtualization today still leaves much to be desired when it comes to usability. For most users, it is still complicated to create virtual machines with advanced media capabilities, including 3D acceleration. 3D-accelerated guests are a must-have nowadays and most desktop environments leverage it to provide a smooth user experience. Existing approaches attempting to grant 3D capabilities to virtual machines are not straightforward, sometimes incompatible and often require trade-offs between usability, performance and security. As a result, a successful implementation on a single host typically requires careful considerations and is often hardware-dependent. For instance, passing through real hardware to a virtual machine using vfio-pci is only possible if the piece of hardware is well-isolated in a single IOMMU group. Paravirtualization, on the other hand, and especially virtio-gpu, promises to be hardware-independent but is not (yet?) supported by all modern guest operating systems.

What if an operating system was designed to provide the best experience regardless of the guest operating system in use?

Everyday lots of people have to deal with agreements, contracts, budget plans, and other similar documents. In this regard, an ability to automate work with such files seems appealing. With this understanding in mind, ONLYOFFICE has been working on Smart Forms intended for optimization of file creation and collaboration in any document flow.

In our presentation, we’ll tell you about the newly introduced ONLYOFFICE Forms, new formats (DOCXF and OFORM) built with the purpose of creating standardized document templates and working with them through specifically designed interface elements in ONLYOFFICE Docs.

Presentation milestones:

• What's the difference between ONLYOFFICE Forms and Content Controls
• OFORM and DOCXF
• How Smart Forms work in ONLYOFFICE
• Form sharing
• Data protection in forms
• Creating and filling PDF files in ONLYOFFICE Docs
• Using ONLYOFFICE Forms in your infrastructure (e.g. Nextcloud, Alfresco, Redmine, etc.)
• Roadmap for smart form development

Two designers came together to tackle this under-addressed issue in OSS. In this talk, we'll cover - How design principles have shaped our understanding of the technical challenges in implementing accessibility in OSS, such as writing 'alt-text' for scientific diagrams - Learn about the real impact our workshops have made in NumPy, JupyterLab and scikit-learn - How other OSS projects can host their own accessibility workshops and sprints

Designers have valuable skills that go beyond the visual arts: the ability to zoom out and see the big picture, finding connections between disparate objects, and creating a pleasant user flow.

It is exactly these skills that make designers such valuable mediators of accessibility!

Mediators are required as the needs of accessible technology and OSS can seem at odds: - Accessible technology needs to recognize the variety of disabilities, that there are many possible solutions, and to create cohesive alternative experience - OSS needs flexibility and variety: it is exactly because individual contributors add different things that it can be difficult to uniformly follow any sort of guidelines for one disability, much less for a variety of disabilities

This talk will explore how two designers came together to start mediating for more accessible OSS. Hear about our messy beginning trying to decode terms and guidelines, talking to developers of what they need, and finally creating accessibility-focused workshops for NumPy, JupyterLab and scikit-learn that have already made changes to the codebase.

Designers will leave with an understanding of accessibility, their role in it and actionable steps, such as how to host their own accessibility workshops in their communities.

Note: While accessibility is a broad term that encompasses accommodating for a variety of disabilities, this talk focuses on making OSS accessible to people with visual disabilities via implementation of 'alt-text' for scientific diagrams.

Video is foundational to the web experience, representing roughly 80% of internet bandwidth. Using desktop, mobile and other devices, video is how individuals learn, work, create, are entertained, and share their human stories. Given that all industries have a need for video and that mainstream audiences are increasingly interested in Web3 solutions, understanding the advantages of decentralization and openness at technical and user levels is essential if these solutions are to be successfully adopted. Join this talk to learn about how Livepeer is positioning itself as the video infrastructure layer of web3 and opportunities for open source contributors to build the future with us.

Backup and restore methods are concepts that everyone knows the importance of. Over the years, open-source tools emerged like MyDumper, Xtrabackup, and Mariabackup. Also, with MySQL 8 new shell, new utils for dump and restore were introduced as well.

In this presentation, we are going to compare the newest backup/restore methods with the most used ones. We will see how parallelization can influence the speed of backup and restore process and also how the compression algorithms can influence the performance.

In this talk, we will compare mysqldump, mydumper/myloader, mysqlpump, MySQL Shell utils, and Xtrabackup.

In this presentation, I will share our community's ongoing exploration of running modern and "standard" Linux distributions on vintage hardware - AOSC OS/Retro. AOSC OS/Retro, as an official branch of AOSC OS (the modern-device-facing mainline), runs a generally similar feature set - systemd, Glibc/Binutils/GCC/Coreutils/Util-Linux, X.org/Mesa, etc. and shares the same source tree with the latter.

With over a year of spending our spare time on the project, tweaking features, designing a desktop experience, and optimising compiler flags, we have a usable distribution that could run on systems as slow as a 486SX, and as fast as "modern" Core Duo systems. We also have an active effort to port AOSC OS/Retro across multiple architectures, with the tally currently standing at eight architectures - and counting (alpha, armv4, armv6hf, armv7hf, i486, loongson2f, powerpc, ppc64). We still have a long list of issues to solve, such as login delays and throttled I/O on ISA-based systems. I hope to gather feedback and criticism through this presentation.

• What is AOSC OS (self introduction)?
• What is AOSC OS/Retro (and how it differs from AOSC OS)?
• Design Goals and Self-Afflicted Agonies
• Application Stack and Software Selection
• End Results (so far)
• Thoughts, Reflections, and Questions
• Q&A

This short talk will disect the container ecosystem for HPC in four segments and discusses what to look out for, what is already settled and how to navigate containers in 2022.

Discussion between Standards panel's speakers.

Oniro - the Eclipse Foundation's embedded operating system - is switching from libstdc++ to libc++ by default. This talk gives an overview of our experience daring to make the switch.

Oniro - the Eclipse Foundation's embedded operating system - is switching from libstdc++ to libc++ by default.

Binary compatibility is a holdup for libc++ adoption on Linux desktops and servers - but in the embedded world, we have more options.

This talk gives an overview of our experience daring to make the switch.

Privacy on the internet is stuck in a vicious circle involving tech and legislation, which we need to escape.

It takes far too long for legislators to transpose directives. The data industry uses an arsenal of dark patterns and technical stunts to creatively interpret or completely circumvent the applicable law.

A new approach is needed to solve this problem in a sustainable way and make the web a better place again. In our talk we will give a brief insight into problematic patterns and techniques as well as approaches to overcome them.

We are Frederik and Hendrik. We're building a fair and open web analytics tool and want to share what we discovered along the way with the FOSDEM audience. This lightning talk will be given by us together.

Several months ago, a new project was started: FerretDB, an open-source alternative to MongoDB. It is a proxy between MongoDB clients/driver and PostgreSQL, developed in Go. Since the very first commit, it used a version of Go which soon will be released as Go 1.18. The two biggest reasons for that were first-class support for type parameters (generics) and fuzzing. In my talk, I will cover both of them: how they work in theory and our practice, how they were useful for us (spoiler: very useful), and what are their downsides and gotchas.

Intel, AMD, ARM, all have launched their own TEE. Amazon can be added to that list with AWS Nitro, but unlike the others it is not a hardware manufacturer. Instead, it chooses to provides its own abstractions over the platform used. This leads to some interesting characteristics. The Enclave Development Platform (EDP) is a TEE platform SDK developed by Fortanix. EDP already targeted the Intel SGX platform. Recently we also support the AWS Nitro platform. In this talk we discuss the AWS Nitro platform in detail and interesting design decisions we made for the EDP platform.

In the AWS Nitro architecture, the hypervisor plays a key role. Hardware resources (processor cores and memory) are split off of a parent VM and can be repurposed to run the Nitro enclave. This enclave can be viewed as a separate VM with only processor cores and memory. A hard disk drive is not present, nor can it directly access an Ethernet network. All communication needs to take place over VSOCK to the parent VM. An attestation report can be provided by the hypervisor to ensure that the enclave has been build correctly. The Enclave Development Platform (EDP) provides a way to easily build Rust applications on top of TEEs. It should be as easy for developers to target TEEs any other modern operating system. Next to Intel SGX, the Nitro platform has been added recently. To target the Nitro platform, EDP reimplements parts of the Rust standard library. It takes care of starting a runner process in the parent VM, forwarding network packets to/from the enclave and providing attestation evidence.

The way to a new build Environment: goto SCONS

In this session we introduce and explain the integration between LAVA (Linaro Automated Validation Architecture) and GitLab as part of the testing efforts in the Oniro OS from Eclipse foundation. The session will cover brief introductions to LAVA and Oniro, integration with GitLab and also present on how we provide vendors the opportunity to test the full software stack on the live devices in-house in completely integrated manner with the main lab and have the test results available for reporting in the upstream gitlab instance.

The Composite CBOS is in many ways a traditional micro-kernel. Services and policies are implemented at user-level, the kernel focuses on fast IPC, and it uses a strong capability-based access control mechanism. It has historically focused on being a research laboratory for strange features including a thread-migration-based IPC, user-level scheduling of system-level threads, user-level definition of capability policies, a wait-free kernel that scales linearly with increasing cores, and temporal capabilities to coordinate between untrusting schedulers. It also scales down and supports paravirtualized RTOSes on microcontrollers (with on the order of 64KiB SRAM, between 16 and 200 Mhz, and MPUs). Composite represents a design that deviates from the L4 lineage in some interesting ways. In this talk, we'll discuss the design with a focus on how the system provides the challenging combination of predictability, performance, and scalable parallelism.

Reactive programming has become commonplace in many kinds of software, while others, including games, have been slow to adopt it. There is an idea stretching back to the 70s that enables reactive programming in an extremely general way: rules engines. This talk will demonstrate pararules, a breakthrough rules engine for Nim. It will demonstrate how games and other software can define their entire logic as a series of independent rules, and how it decouples your data much like (but more powerful than) an entity component system. It will show why this kind of library is only practical to implement in a language with a Lisp-like macro system such as Nim's.

GitHub has a nice environment for carrying out repository-event triggered workflows; these use a variety of runner platforms, including containers. This talk is about how to create a Raku container that can successfully act as a runner for workflows, and how to Rakuize the workflow API so that Raku scripts can interact meaningfully with this environment.

There are two parts on this talk; first, how to create a chain of increasingly complex Raku containers that can be used mainly for testing, and second, how to run some Raku scripts within those containers, with cool things that can be done inside those workflow using Raku.

Sometimes you shouldn't do something just because you can. Really. Nevertheless, you can. This talk will explore the creative, occasionally useful, often unhealthy things that you can do with triggers. Attend at your risk.

In biomedical sciences, ontologies are used to annotate and organize data stored in knowledge databases and facilitate their exploitation. Following the pioneering work of the Gene Ontology at the turn of the century, the Open Biomedical and Biological Ontologies (OBO) Foundry was created to coordinate the development of a family of interoperable ontologies sharing a core set of principles. The Foundry now includes more than 150 ontologies. The Ontology Development Kit (ODK) [1] was developed to facilitate the implementation of standardized ontology development practices across the Foundry. It takes the form of a Docker image that provides ontology editors with all the command-line tools they need to manage, edit, build, and test their ontologies, as well as standardized and carefully crafted Makefile rules to pilot all steps of the ontology life cycle. In recent years, many ontologies such as the Uberon multi-species anatomy ontology, the Cell Ontology (CL), or the Unified Phenotype Ontology (uPheno) have been converted to use the ODK. By moving most of the management, building, and testing logic from the individual ontologies to the ODK, the kit aims to make the life of ontology editors easier, by allowing them to focus solely on actual ontology editing, all the while contributing to the standardisation of the various ontologies.

[1] Nicolas Matentzoglu, Chris Mungall, and Damien Goutte-Gattat (2021). Ontology Development Kit. doi:10.5281/zenodo.5762512

Sometimes state management shapes the application architecture, which we even interchangeably call state management, app architecture. State management is a controversial topic among all developers, and it's, at the same time, one of the most complex topics that developers should decide on when they are building a Flutter app. Many developers say one solution is the best, whereas some disagree! What if I tell you that, in my opinion, there is no right and wrong answer! If you ask a software architect, which state management is the best for an application? The answer is evident; It Depends. This talk discusses how to think like an architect and understand, recognize, and analyze tradeoffs and characteristics when choosing state management. I will show you why all state management might be best and worst, at the same time for your application which eventually helps you to make your mind to determine your appropriate solution.

The use of Bare Metal to run containerized workload is coming back into popularity. There are multiple reasons for this increase of interest. First, the rise of big data analytics, high performance computing, machine learning workloads that need high-bandwidth and low latency and sometimes even requires access to special hardware devices like GPUs or DPUs. And at the same time, in the telecommunication space, the 5G networks technology stacks that drive the need for IPv6, SR-IOV, Container Network Functions (CNFs), NUMA topologies, and other innovations in containerized applications on bare metal.

All of these emphasize the need for the ability to easily create Bare Metal based OpenShift clusters as automatically as possible.

Central Infrastructure Management (CIM) exposes an intuitive user interface, allowing the infrastructure administrator to define a pool of Bare Metal machines making them available for users to independently create OpenShift clusters from them.

Assisted Installer is an operator that introduces a new way to deploy a new OpenShift cluster on bare metal basically by only booting the nodes that will be part of the cluster, with an ISO it generates. The Assisted Installer will report inventory, run validations and orchestrate the needed steps based on the user parameters.

CIM and Assisted Installer are components of Open Cluster Management (OCM), an operator that enables a single OCP cluster to manage a fleet of clusters.

In this session, you will learn about Central Infrastructure Management and Assisted Installer architecture and its components. We will discuss the installation flow and how the components interact with each other. Finally, we will demonstrate how to build a pool of Bare Metal and install an OpenShift cluster on them via the CIM user interface.

Peer to peer to protocols (P2P) are useful for creating applications that are less reliant on central physical and digital infrastructure. With a p2p backend, an application can easily move between connecting people over the internet, to local and ad-hoc networks, and working entirely offline. We take this ability a step further by integrating several protocols into web browsers so that applications can be authored and distributed just like any other data in the network.

This talk will go over some of these protocols, their strengths and weaknesses, and how we have applied them to the web. We'll also have a live demo of what it looks like as a developer.

This talk will be using the desktop version of the open source Agregore Browser, a minimal web browser built on top of the Electron framework which deeply integrates several protocols everywhere that a browser might use a URL.

The specific protocols we will be going over are IPFS, Hypercore-Protocol, and BitTorrent.

We'll also be talking about the benefits of using P2P software in ad-hoc mesh networks and how it can enable communities to make the most of their local networks.

Feel free to install the browser ahead of time if you'd like to follow along for the live coding portion.

Network Automation has evolved a lot on the last years, adopting a lot of the practices from SDLC (Software Development Life Cycle) but with the intrinsic constraint of networking services. In this talk you will learn about which are the challenges and common use cases around network automation, for instance: configuration management, user-driven workflows, infrastructure as Code (for hybrid and multi clouds) or close-loop automation using Telemetry. You will realise how a lot of open source projects are coming together to provide solutions to the previous challenges from different angles and how you could connect them together to start building a network automation strategy that could transform your network with lower OPEX, improved reliability and security, and increased innovation.

Wikipedia and Wikimedia Commons are a treasure trove of free information about a lot of topics! Wikipedia alone contains over 50 million articles in almost 300 languages. We're building a new, fun way to explore this content: "The Everything Exhibition" is an open-source generator that creates interactive, virtual 3D exhibitions on arbitrary topics, which you can explore in the browser! It has a multiplayer mode, so you can visit the exhibitions in groups. And, other than in a real museum, you can scribble on everything!

In this talk, we want to introduce you to how the generator works, and show you our current progress. We're using the 3D rendering engine three.js, and defined a simple datastructure for describing the exhibition content, to make the generator arbitrarily extendable. We'll go into which algorithms we tried for creating the room layouts, share what we learned in our playtest sessions, and talk about what's next.

With this project, we especially have young people in mind, who are often already used to 3D games and environments. But the Everything Exhibition allows everyone to really get lost in these delicious rabbit holes! :D

In this workshop, you will learn how to plan and conduct a remote workshop. It will cover helpful tools and methods, energizers, and collaborative design. On top of that, you will get insights and first-hand experience solving workshop issues like scheduling over timezones, mixing real-life and remote settings and involving people even in virtual formats.

The open-source software company Grafana Labs successfully holds virtual workshops in a remote setting, both with small and large groups. Facilitator Jess will show how she conducts such workshops and teach you her tried and tested insights – in an interactive workshop format!

The cloud-native approach based on containerized micro-services has transformed the software landscape but is largely focused on non-real time web-based applications, especially in the case of service meshes which use web proxies to interconnect workloads. Media Streaming Mesh uses real-time media proxies to observe, route, encrypt and protect north-south and east-west media traffic.

This talk introduces the Media Streaming Mesh architecture and its use-cases, gives an update on implementation status, and acts as a call to arms to recruit more contributors.

In this talk, pidge will take a critical look at the places where meta-zephyr succeeds and fails in its original goals, the reasons behind that and the steps being taken to fix those issues.

OpenEmbedded, Zephyr and meta-zephyr are powerful tools that can give IoT developers the ability to rapidly develop embedded solutions. Integrating them all however is challenging, made more so by wrapping multiple build systems, machine configurations and build languages into a coherent solution.

In this talk, pidge is going to show changes being implemented through her work on the Eclipse Oniro project to the meta-zephyr layer that bring most zephyr supported machine configurations into meta-zephyr but also removes the need for OE machine configurations to have any knowledge of core zephyr modules. She will discuss the issues she encountered around integating those changes from the zephyr side.

The Libre-SOC Project aims to develop a family of OpenPOWER processors, ultimately working towards a full hybrid 3D CPU-VPU-GPU. After two years of development funded by NLnet, the current phase is to develop a Gigabit Ethernet Router ASIC. Funded by NGI POINTER, this ASIC is intended to be capable of running OpenWRT with OpenPOWER-compliant RADIX Virtual Memory.

This talk will provide background, a status update, and go through the incremental development and debugging that is leading up to being able to boot a microwatt linux-5.7 kernel with a buildroot initramfs, under verilator.

BellSoft created tiny containers based on Alpine Linux. But Alpine has its cons: musl sometimes performs worse than glibc, LTS support is not long enough. So we developed Alpaca Linux based on Alpine. Alpaca is more performant and secure, has longer LTS support, and is perfect for Java deployment.

The size matters when it comes to containers: they should be small but performant. BellSoft engineers came up with the solution and integrated the Alpine musl port into JDK 16. We made containers based on Alpine Linux and immediately understood that we hit the spot. These containers are still in demand and keep gaining popularity. Alpine Linux is based on musl. There is usually no difference in performance, but in some cases, musl is less efficient than glibc. The problem is that any Linux distro is made for general purposes, and Linux engineers don’t have Java in mind when developing them. In addition, LTS support for Linux kernel and OpenJDK is longer than that for Alpine Linux, which leads to a more frequent migration between OS versions within one Java release. We want to make sure that Java LTS visions are stable within the environments we offer. This is why we created our own distribution, Alpaca Linux, based on Alpine. Alpaca Linux has a longer support cycle and includes musl-perf and other components to boost the performance of apps, including Java-based ones. In my talk, I will describe the differences between Alpaca and Alpine and show the results of the benchmarks. I will also tell you about the Alpaca release cycle and how to get hands on with this new Linux distro. You will find out how to boost the performance and security of Java deployment with Alpaca Linux. All in all, I think that this is the beginning of a beautiful friendship between Alpaca and Java.

Although Linux is still the best preferred operating system, the talk begins with a problem statement regarding the dependencies of ANTLR and LLVM on Windows. To this end, the presenter will explain how these dependency issues can be resolved through an easy-to-use environment for building, installing and running native LLVM and ANTLR on Windows. Furthermore, the talk will briefly explain how we can design domain specific languages (DSLs) using a powerful combination of ANTLR and LLVM front end while maintaining a logical isolation of parsing and code generation.

LibreOffice was capable of handling color palettes on its UI for a while already. In the meantime, the competition introduced document themes, which are a fixed set of 12 colors, to be attached to various parts of documents. This allows referring to those colors by name, and apply color filters. These color filters are maintained even if the source theme changes. Come and see how this now starts to work also in Impress, what still needs doing and how you can help.

It's been just over a year since all browsers dropped support for Flash, but much Flash content continue to exist both in web archives and on the live web. This presentation will cover various techniques tried by the Webrecorder project to keep Flash content still working in today's browsers, such as running old browsers in containers, running full system emulation in WebAssembly, and using the Ruffle emulator. We will cover the trade-offs between these approaches and the current challenges in combining web archives and emulation, and present the tools we have built to make these approaches possible.

As one of the options, will also talk about the OldWeb.today project (https://oldweb.today/) which provides several JS-based emulation connected to web archives, how it works and how it can be used to run not only Flash, but also old Java applets that may exist in web archives.

We will leave time for a Q&A session to answer any questions about the tools and how they could be improved!

Optimizing CPU management improves cluster performance and security, but is daunting to almost everyone. CPU management may seem complex, but it can be explained in such a way that even your inner toddler will comprehend. With this talk, we will give a path to success.

You may have a multi-socket node cluster where your AI/ML workloads care about the proximity of your CPUs to GPUs. You may be running scientific workloads where you want to pin in cores within containers instead of just a pod level. You may have a single-socket server where you want to save a single core outside of Kubernetes for a daemon dedicated to mining bitcoin, without affecting your other jobs (please do not do this). We will cover these and more, helping you understand the intricacies of CPU management within the kubelet and what Kuberenetes can and cannot currently do. We will also cover how you can help escalate the visibility of use cases not currently covered within Kubernetes.

Many clusters do not have CPU management because it is difficult to do correctly without impacting performance. While there are static and dynamic pinning abilities, we will consolidate the use cases and remove the pain it takes for users to deploy Kubernetes. This talk will help the audience gain an insight into features that can be used for resource management and orchestration of containerized applications with focus on CPU management. Users that have performance sensitive workloads such as AI/ML, Telco, 5G and Networking workloads will benefit from this talk. This talk will also help CTOs, system architects, developers and engineers in their planning to develop, test, or optimize their deployments in a Kubernetes environment. We also hope to use this forum to find other community members with specific needs in our desire to make the kubelet more flexible with regard to CPU management.

The ever-continuing push for digitalisation has increased our reliance on trust services of various kinds, filling various needs relating to document signing, code signing, authorization tokens, and so forth. Many of these trust services rely on public-key infrastructure (PKI) and X.509 certificates.

The sensitive nature of these tools makes them difficult to use in a testing environment. On the one hand, exposing access to production keys in your CI is obviously a terrible idea. But on the other hand, setting up and maintaining a fully functional "mock" PKI environment is also pretty tricky. What can you do about that?

Using PKI tools in test workflows involves many challenges. Here are a few examples:

• Even a (supposedly) basic task like validating an X.509 certificate involves quite a bit of complexity. Apart from "local" validation logic, you might also have to check the revocation status of your certificate, which could entail talking to an OCSP responder service or looking up a CRL.

• If you're using secure timestamps (RFC 3161) in your code, your tests might also require access to a time stamping service.

• Maybe you're using a remote signing service vendor that doesn't offer any sort of "sandbox" for testing purposes.

In all of these scenarios, both test data generation and mock service integration can be quite cumbersome. Both in my own time and on the job, I write a lot of code that relates to digital signing in various ways, and this is a kind of problem that I run into all the time. After trying out a variety of methods, I grew dissatisfied with the "traditional" options, and rolled my own PKI testing framework: Certomancer. Certomancer helps with both test data generation, performs trust service mocking, comes with a plugin API, and most importantly, it's FOSS (MIT licence).

In my talk, I'll take you through some of the "how"s and "why"s of Certomancer's feature set, and talk about some of the mileage that I've gotten out of it.

While the world is moving toward SaaS and Cloud infrastructures, many companies want to keep things in a self-hosted platform or in a private cloud. We’ll talk about all the challenges of building a product that gives users complete control over their data, and how we overcame them, such as migrating from a monolith to services to allow scalability, managing secure service discovery, detaching database from the infrastructure, or managing an easy service installation without any orchestrator. In January, we have released Carbonio CE (Community Edition) source code to show the results of our work. Contributors are welcome!

The hows and whys of using HTML-validate to automate accessibility testing for SPA.

Short break.

The Wikibase Stakeholder Group is a new initiative testing alternative approaches to governance, decision-making and community-building for open source digital knowledge management. It aims to facilitate collaboration across various institutional and individual partners in order to ensure the continued development and long-term sustainability of Wikibase, a suite of tools for data management within a linked open data environment. Wikibase is currently developed and maintained by Wikimedia Germany, a chapter of the non-profit Wikimedia Foundation. Wikibase is vital infrastructure for the public linked data project Wikidata, but since its open release in 2015 it has been increasingly taken up in research, cultural and institutional contexts due to its flexible, open and collaborative architecture. Rhizome have been piloting the use of Wikibase within GLAM contexts since its release, and have co-organized the first set of public meetups and events around the emerging Wikibase community and ecosystem of decentralized Wikibase instances. Following the success in bringing the community together through these events Rhizome and a few early adopters started the Wikibase Stakeholder Group at the end of 2020. In this talk, we will present the activities of the Group to date, lessons learned from our experiences in collective decision-making, funding for collaborative development efforts, and negotiating between individual project requirements towards a common roadmap in line with ongoing efforts of the Wikimedia team.

Expected prior knowledge / intended audience: No prior knowledge is required for this talk, except general familiary with open source community contexts and open data management tools. The intended audience is other practitioners actively involved in open source communities, in the governance and organization of communities, and/or the development of tools for linked open data management.

The MariaDB Connection ID exists since "ever". So why bother about such a boring thing? Because you can get many interesting information out of it...

Hardware-accelerated graphics is becoming an essential part of modern computing environments, yet it is currently very difficult to impossible to use in secure environments such as Qubes OS. SR-IOV promises to solve this problem, but multiple problems have limited its adoption. This workshop is about these problems and about what is needed to solve them.

We'll look into JSON serialztion, starting from the easy cases and moving toward more advanced ones.

A quiz! Consider the following code:

a := 1
data, _ := json.Marshal(a)
var b interface{}
json.Unmarshal(data, &b)
fmt.Println(a == b)

What will be printed? And why it's "1 1 false"? :)

We all work with JSON, and even though it's a simple format, there are several sharp edges you should should avoid. In this talk, we'll journey from the common well lit areas of JSON serialization and end in some darker corners. I hope you'll enjoy the ride.

We are living in exciting times - we are finally seeing hyperscale server platforms opening up and running on open source software (with caveats still). The journey though is a road full of potholes, braking and sharp turns. Opening up hardware is not easy! Follow along and see how we enabled the Mono Lake platform that was originally created by Facebook (now Meta).

Opening up hardware is a difficult process. But necessary for those who are part of the circular economy. Being able to extend the life of hardware platforms by making community supported can be quite a lift but the end is can be filled iwth possibilitles. While there has been many instances of open hardware - none though is built to run as hyperscale platform in data centers.

The Mono Lake platform was originally open spec'd and built by Facebook (now Meta) - with it, we can build powerful data center class computing engines that run modern workloads. But because the platform is 4 years old, it needed to move from a singular purpose to general purpose. This talk will be focused on the journey of opeining up the Mono Lake platform and the end result and the work still left to do.

Emulation of classic hardware is a solved problem and like all solved problems that are sufficiently fun it attracts countless new implementations every year. This has led to the creation of many public test suites — test suites independent of any particular emulator, which can usually even run on real hardware. But these suites tend to assume a lot of working functionality beyond the part they are specifically testing, being designed by an intelligent human being to test complete emulators holistically.

This presentation covers an alternative source and target of emulator tests: random numbers, to test individual processor instructions, so that future emulator authors can test from day one.

Working with big data matrices is challenging, Kubernetes allows users to elastically scale, but can only have a pod as large as a node, which may not be large enough to fit the matrix in memory. While Kubernetes allows for other paradigms on top of it which allows pods to coordinate on individual jobs, setting them up and making them play nice with ML platforms is not straightforward. Using Apache Spark and Apache Mahout we can work with matrices of any dimension and distribute them across an unbounded number of pods/nodes, and we can use Kubeflow to make our work quickly and easily reproducible. In this talk, we’ll discuss how we used Apache Spark and Mahout to denoise DICOM images of lungs of COVID patients and published our Pipeline with Kubeflow to make the process easily repeatable which could help doctors in more resource limited hospitals, as well as other researchers seeking to automate the detection of COVID.

This talk will cover the creation of two web portals, which use open source libraries to make much of the modern web accessible to vintage machines and old web browsers. By using the Readability library, along with some haphazard PHP, I was able to take modern sites down to text content and HTML 1.1 on the server side. FrogFind.com serves as a web portal for limited browsers, such as old versions of Mosiac, or even text browsers like Contiki's on an Apple ][, to make much of the web's content accessible to them in a perfectly readable way.

It is often said that the modern internet has left vintage computers behind. However, it is not the internet - it is the complexity of content. One way of bringing vintage machines to the modern web is through upgrades and accelerators. This creates a moving target of machines that will still age-out of sufficient upgrade-ability as the web continues to evolve. Another option is to deconstruct the modern web to make it accessible to vintage computers.

Using an open source library called Readability and some haphazard PHP, I've built two web portals: 68k.news and FrogFind.com. These sites allow vintage machine to view many websites as text-only, by stripping out complicated HTML and scripts and delivering HTML 1.1 content to old browsers, with images optional.

This talk will cover the idea behind these portals, their use, and just how usable and pleasant a vintage machine can become for daily internet content consumption without the distractions of the modern web.

Foxfooding is Mozilla's internal dogfooding process that includes both employees and community members. The goal is to encourage all Mozillians to give early feedback about the products that we are shipping, in an open and collaborative way.

In this talk, I will present a new Spectre/Meltdown mitigation that I have prototyped for the Hedron microhypervisor. This prototype has also been used to quantify the runtime overhead of the proposed mitigation.

Processor-level vulnerabilities, such as Meltdown and Spectre v1/v2, allow attackers in userspace to leak information from the kernel address space. This is particularly devastating for kernel designs where the kernel address space is identical for all processes and thus allows the attacker to break the system's confidentiality boundaries.

Previous mitigation attempts, such as kernel page-table isolation (formerly KAISER) for Meltdown and various branch predictor/speculation barriers for Spectre v1/v2, introduce costly instructions into performance critical parts of the operating system kernel. Especially mitigations related to the branch predictor are only possible if the CPU vendor has exposed special functionality.

During the last six months I investigated an alternative mitigation strategy on the kernel design level that shows good mitigation properties, but adds negligible runtime overhead. This alternative mitigation involves moving process-related information in the kernel into a process-local part of the kernel address space. A userspace attacker that can infer the content of its associated kernel page table can thus only read information about its own process. Switching between these kernel address spaces is done as part of the normal address space switch when a thread in a different process is scheduled and thus comes with no additional cost.

Inaugural secure enclave platforms operate at the single user process level (e.g. SGX), meaning a single address space with potentially multiple threads, with a standard OS outside the enclave responsible for resource management and scheduling. More recent platforms (AMD SEV, Intel TDX, AWS Nitro Enclaves) operate at the VM level. This provides significant new capabilities for multi-process abstractions such as mmap and fork, which will be beneficial for enclavizing legacy software.

However, taking a VM image and running it in an enclave is not great from a TCB minimization standpoint. For platforms where there's currently no alternative (AMD, AWS), how can we build--with a minimal TCB--an abstraction that's similar to single-process enclaves? Of course you can “just run Linux” with a single process but this again is clearly suboptimal. We'll explore the solution space in this interactive session.

Discussion between speakers of the Knowledge Management Communities panel.

Open source software can help in building communities around common practices. Damien Goutte-Gattat's talk shows how a piece of software (Ontology Development Kit) can help ontology editors to deploy their tools and at same time foster standardized ways to write and publish their work. A double benefit grounded in FOSS practices.

But Open source software also benefits in return of organized users communities. Lozana Rossenova and Dragan Espenschied present the Wikibase Stakeholder Group which gathers a community of wikibase server and its plugins users and developers. A detailed explanation of how to care a community around a FOSS.

Those two sides of community building around knowledge management will be discussed with the speakers in a live discussion panel. Questions from the audience will be collected from the textual chatroom and voiced by the session moderator.

Understand containerised deployment with Open-Source CSP (Content Service Provider) platforms. Both Alfresco and Nuxeo products provide an easy Docker Compose deployment that allow early adopters and enthusiast developers to use the platforms.

Public deployment templates are be provided, including detailed instructions on how to use them:

• Alfresco deployment using https://github.com/alfresco/alfresco-docker-installer
• Nuxeo deployment using default Docker Image from https://github.com/nuxeo/docker-nuxeo

Camera support has traditionally been a pain point when it comes to Linux phones.

Years and years of competition on the photography capabilities of consumer devices have pushed vendors to adopt more and more custom, closed source implementations, leaving users of free software powered mobile devices with nothing but poor solutions limited to work on the single devices they have been developed for.

With the increasing maturation of libcamera, a complete user space camera stack for Linux devices is now finally available, and Linux phones developers can now cooperate on more mature camera solutions for their devices.

The BoF will serve for phone developers and camera developers as a cooperation space, to better understand their mutual needs and move forward camera support for the whole Linux ecosystem.

Cameras have traditionally been a distinguishing factor in the traditional mobile/smartphone market. Year after year the number of pixels available in a phone's camera have become a stable part of the phone producers marketing material and as a direct consequence of such fierce competition everything around cameras has usually been quite secretive, with vendors implementing rather cumbersome software architectures to work around the software licensing requirements which would have otherwise required them to open at least part of what they consider their secret sauces.

Vendor's reluctance to discuss and innovate in a common shared space and the undeniable deficiencies (or better, the complete lack of existence) of anything resembling a camera stack in the Linux ecosystem has pushed camera support to a quite uncomfortable position when it comes to FOSS-powered mobile devices. Until very recently nothing comparable to what could be achieved by a rather cheap Android phone, running binary blobs both in user and kernel space, can be easily realized by using a fully open infrastructure.

Three years after starting of the libcamera project, its adoption as the default camera stack for the Raspberry Pi ecosystem and its increasing permeation in the x86 device space thanks to the support of vendors like ChromeOS and a more robust integration in Pipewire, it's now time to finally address the camera issue in the FOSS phone space.

With the recent interest from Librem5 and Pinephone communities in the project, this BoF intends to provide a space where phone developers, libcamera developers and hopefully vendors can discuss their mutual headaches and try to sketch a way forward in order to provide to free-software equipped mobile device a camera support that can do more than what an Android phone was capable of 10+ years ago.

Numpy is considered the go-to library for fast performant python scientifc computing, as it is a heavily optimized scientific computing library written in C. But is it really that fast (spoiler: yes, but not when used with python)? In this talk, I will be covering a real-world example in the domain of genetics, and demonstrating how I was able to out-perform numpy code running on my intel-7700k machine with a raspberry pi running code from the Nim programming language!

I will also be providing optimization tips for speeding up your code, with a focus on comparing python with the Nim programming language.

The talk can be roughly divided into the following sections:

Part 1 (32 min) - Introduction to myself. Describing a computationally expensive problem that I have experienced when working with Python. - My background is in data science and biology - Biologists tend to work with large datasets - One common problem we face is preprocessing of large amounts of data. A common technique used here using distance calculations - Why I decided to learn a different language Part 2 (1 min) - High level introduction to Nim - Nim is a statically compiled programming language - Etc... Part 3 (10 min) - Going through step-by-step on how to write performance optimal code with Nim. Describing common performance pitfalls that Python users may not be aware of. - Inlining - Using the type system to your advantage - Taking advantage of domain knowledge - Multi-threading (openmp) - Bounds checking - Compiler flags - Mathematical and algorithmic optimizations Part 4 (3 min) - Benchmarks and closing statement - Show benchmark comparing the naive python numpy implementation with the highly optimized Nim one - Top tips to keep in mind when writing high performance code.

Please note: the purpose of this talk isn't to be an exploration of some new state-of-the-art way of doing performance optimization or some relatively unknown optimization techniques. This is a general introduction for people hoping to use Nim for HPC that are coming from Python. Lots of emphasis will be put comparing the two languages.

Today, the LibreOffice Technology platform is based on the same software engine for all modules, based on a clean and refactored source code, with a focus on code quality and consistency, and supported by easy and extensive APIs. LibreOffice consistency represents a strong advantage over the "siloed" approach of all other office suites, where there is a different software engine for each application and each platform. The result is a lack of consistency for files, which are also different by platform. LibreOffice Technology is the best open source platform for personal productivity, and is tightly integrated on desktop, mobile and cloud.

Automated browser end-to-end testing is a powerful technique to ensure your web UI and backend work together nicely. In this talk, we show how we've leveraged Microsoft's Playwright library to refactor our test suite, enhance productivity and code quality.

At ownCloud, we pride ourselves in shipping well-tested code. Besides the typical unit- and integration-tests, we use automated browser/end-to-end tests for our new web frontend, which is supported both by our "ownCloud classic" backend as well as developed alongside our new generation "ownCloud Infinite Scale" backend.

Confronted with a flaky and complex continuous integration suite of end-to-end tests that was not actively maintained, hard to reason about (as well as sub-optimally documented due to the original creators leaving the project and running for, well, "longer than acceptable"), we opted to switch from Selenium/Nightwatch to Microsoft's Playwright (playwright.dev).

Tune in for this talk when we show how our test suite evolved over time, listen to our reasoning about the technological switch, and also learn from the mistakes we made and best practices we extracted into practical examples.

A technical overview of how the FOSDEM conference is run: the tools we use, the tools we wrote, and the processes we use; both for the in-person version of the conference as well as the online one of which we're doing our second edition this year.

FPGAs are increasingly being used in today's embedded systems. But they are notoriously complex for having a difficult programming model. In order to counter this complexity, there has been a growing focus to design FPGA hardware at a higher level of abstraction with new languages and compilers. This talk will serve as "one stop shop" for topics related to these developments.

Are you an embedded developer? Do you like FPGAs? Do you want to know the best programming practices for embedded systems that deploy FPGAs? Do you like economical hardware? Do you like open source projects? If your answer is "yes" to either of the aforementioned questions, then this talk is for you. As the title goes, this talk and its content will actually be "one stop shop" for best practices related to FPGA programming. Considering C-based languages still dominate the embedded systems, the talk will focus on new methodologies that can be broadly implemented while using all C-based (C/C++/C#) languages when it comes to implement your designs on FPGAs. To take it further, the talk will shift focus on C++ as C++ is finally picking up pace to come even more closer to low level hardware as compared to previous C++ standards. The last four C++ standards have come a long way to make C++ language even more compatible with embedded systems. Many open source FPGA libraries are based on modern C++. At the end of the day, you will know how a modern embedded developer can adopt certain coding practices to fully exploit the underlying spatial parallelism of FPGA hardware. Additionally, you will learn about open source compilers, open source projects, and economical FPGAs hardware to implement these best practices.

The talk will discuss current state of Unit testing in the Apache OpenOffice project and the effort to update the test suites to be useful standalone to run tests against an installed office without being tied to the OpenOffice build process. Also areas where Java developers could get involved.

The Flux Ecosystem is a suite of decentralized computing services and blockchain-as-a-service solutions together to offer an interoperable, decentralized AWS-like development environment. Flux utilizes a native POW coin to power this ecosystem, providing incentive for hardware hosters, governance on-chain, and bad actor mitigation via staking requirements for running hardware. The Flux operating system runs on top of Linux to provide the network with verified, enterprise-grade compute power and utilizes the blockchain to ensure transparency in governance operations. This allows almost anyone to be rewarded for providing hardware to the network, from anywhere in the world.

Raku Steering Council Q&A panel is aimed at the audience interested in the Raku® programming language, its current state, and its future. Members of the Council will try to answer any related questions, including those about the Council itself.

To be a proficient java developer, you must learn Java Thread programming. Thread is the heart of the Java ecosystem. All the server-side programming model heavily depends on the java concurrency model. In this session, I will explain a few essential aspects of the java thread model from the ground up so that a beginner can build up their concurrency knowledge on top of it. The session will include -

1. How to create a simple concurrent program
2. Identify the benefits of java threadings
3. Understanding the bagasse that comes with threads and how to avoid them
4. What are the threadsafe classes available in the JDK

bpftrace is a relatively new open source tracer for modern Linux (kernels 5.x.y) that may help to troubleshoot performance issues in production as well as to get insights on how software really works. More exotic use cases for the tool, as well as few more advanced bpftrace-based scripts useful for MariaDB DBAs and developers are presented.

bpftrace is a relatively new open source tracer for modern Linux (kernels 5.x.y) that may help to troubleshoot performance issues in production as well as to get insights on how software really works. I use it for a couple of years and would like to present more details on how to do it efficiently, including but not limited to adding tracepoints to different lines of the code inside functions, suing bpftrace as a code coverage tool and tracing in Docker etc.

As a side project the Kiwi TCMS team has started collecting facts about people who've made important contributions to the testing field. We're calling upon other testers for ideas and contributions.

Funders, publishers and scientific organizations have highly endorsed the adoption of FAIR principles (Findable, Accessible, Interoperable, and Reusable) to promote research data reusability and reproducibility. However, FAIR principles are high-level guidelines without explicit requirements for their implementation. Practical solutions such as metrics and associated tools are required to support the assessment of FAIR compliance of research artefacts such as services and datasets. This talk will introduce an open-source tool named F-UJI which was mainly developed to support trustworthy data repositories committed to FAIR data provision to programmatically measure datasets for their level of FAIRness over time. The talk will provide an overview the development and application of F-UJI and use cases it has supported so far.

How can your project attract (and keep!) UX designers? I'll list few specific changes that should help. But I have to warn you, these aren't quick hacks. They're small but meaningful changes to your culture that will also improve your product overall.

I gave a talk at FOSS Backstage on UX and FOSS. This is really 'part 2' in the series, making concrete suggestions maintainers can use to help make their projects more UX focused and by extension, help attract UX designers.

5 OpenSource Test Automation tools in 45 minutes! You will be left with a general oversight of various well known OpenSource Test Automation tools which are applicable in a large (or smaller) companies or OSS projects. With a working example demo where you see it in action. The talk will also score these tools (subjectively) among each other (installation, ease of use, stability, speed, etc) and provide insights on how to get started. When to use it, and when not to use it.

In this session the speaker will show 5 well known OpenSource Test Automation tools applicable in the enterprise for test automation. The cool thing is that many OSS projects could also benefit from incorporating therse tools as part of their CI/CD approach. The talk will cover how it could be used and show a working example of the code. This will give a quick glance of various OSS (Test) Automation tools. Some examples are: SeleniumBase, Cypress.io, Cucumber, RobotFramework and Cerberus.

The Go ecosystem has established itself as the language of choice for many cloud and server software. We present arguments that Go is also uniquely suited to thrive for Linux-based embedded development. We present our case in the context of the SysOTA and NetOTA projects

How to create and deploy NFTs with Flutter and the Algorand blockchain.

I will present why we needed to use Canvas for rendering the UI and the document. Then i will explain the structure we created for this task.

Argentina's National Institute of Agricultural Technology (INTA) conducts research and development for the agricultural sector. Environmental conditions influence agricultural activity; in particular, climatic conditions have a favorable or detrimental effect on production. Thus, it is essential to monitor and analyze the different agro-meteorological variables to describe these conditions and their impact on agricultural and livestock production. With this approach, INTA has an extensive ground network of conventional and automatic weather stations. In addition, there is an information system (http://siga.inta.gob.ar) with predefined queries and visualization on this data for internal and external use. All the information generated by the institution is openly shared under a CC-BY-NC license. INTA is a decentralized institution and generates research, analysis, and reports at different scales (national to local). The processes to perform these tasks use various software tools and different methodologies. Moreover, these processes are in the computer and the head of the researchers.
Developing internal packages or libraries has great potential to promote reproducible analysis frameworks, improve an organization's code quality, enhance knowledge management (Riederer, 2021), standardize and make processes transparent, and open software and data to society.

The {agromet} package includes a series of functions that can be used regularly for the calculation of agrometeorological indices and statistics. The input meteorological data works under the tidy data philosophy, so the package functions are generic. They can be applied to any tabular dataset regardless of its origin, order, or column names. However, according to INTA's internal requirements, the package also incorporates tools to read data in an INTA format. This package has implemented functions for calculating indexes and variables of agricultural interest, standardizing how these computations are made. It also incorporates mapping functions with scale and reports templates.

The package {siga} downloads and reads data from INTA's Agrometeorological Information and Management System programmatically.

This talk will discuss the decision process to generate a series of internal packages designed to be used by INTA users but with enough generality to be helpful to a broad community. Their development, current use, and this experience encouraged the generation of similar packages for soil data.

Organization on GitHub: https://github.com/AgRoMeteorologiaINTA

Learn how OpenSearch works and get equipped with practical knowledge to search, aggregate and visualise your data.

This is a hands-on session where we will use JavaScript to interact with the OpenSearch cluster - create an index, add documents, search and aggregate data. At the end we’ll visualise results with OpenSearch Dashboards.

JavaScript engineers who are ready to add search and aggregation features to their applications should attend this session; no previous knowledge of OpenSearch is required.

In this session the audience will get both theoretical and practical knowledge on what OpenSearch is and how they can work with it by using its NodeJS client. This is a hands-on session where the audience is invited to follow along.

There will be an accompanying GitHub repository to allow the audience to follow me during or after the lecture.

References to old talks:

I’ve already run a similar session at AWS Community Day, added its link to the list of links. However, I will modify and improve the content based on the learnings from the previous session. So the content will not be the same.

Audience:

Javascript Developers with no or little knowledge on Opensearch or Elasticsearch.

Have you ever wondered why spreadsheets look and act that way? Why does LibreOffice and Excel use letters for columns and numbers for rows? In this high energy presentation, Jim Hall will discuss a brief history of spreadsheets, from LANPAR to VisiCalc to Lotus 1-2-3 to LibreOffice. A great history lesson and practical demonstration.

The first 'spreadsheet' program was LANPAR, which invented the interactive concept of working with values and originated the idea of forward referencing. But the spreadsheet as you might recognize it today started with VisiCalc on the Apple II. We'll explore several favorite DOS spreadsheets as we review a history of spreadsheets, including: VisiCalc, Lotus 1-2-3, As Easy As, Quattro Pro, .. to to understand why modern spreadsheets like LibreOffice Calc look and act that way.

This is a presentation about the revamp of OpenPOWER platform by the OpenPOWER Foundation

I have reimplemented the Plan 9 cpu command in pure Go, available at github.com/u-root/cpu. It uses the ssh transport protocol for data, and the 9p protocol for file system traffic.

If you are used to ssh, cpu will look very similar, to the point of even honoring your .ssh/config! What's different is that when you cpu from your local note to a remote node, file systems of your choosing are visible on the remote node, mounted over 9p, connected to a server running in the cpu command itself. Translation: you don't ever need to talk to a sysadmin to get network mounts set up. Want to use programs from your local node, libraries from your node, and see your home directory? No problem, run with the default namespace. Is the node a different architecture, but you want to use your /home? No problem, just tailor the CPUNAMESPACE variable, e.g.: CPUNAMESPACE=/home:/bin=/arm/bin:/usr=/arm/usr:/lib=/arm/lib cpu cat /proc/cpuinfo. Want all this from power-on/reset? No problem, we embed kernels and a cpu daemon in flash on any of x86, ARM, ARM64, and RISC-V. Want to embed a cpu capability into your Go program? No problem there is a simple package that implements the Go exec.Command interface. Want to understand cpu? No problem, it's easy to read, consisting of 1164 lines of code for the client and 799 for the server.

This talk introduces Neighbourhoods: a proposed organizing principle for social spaces on the distributed web using Holochain. We envision “groupware” (like calendars, simple games, chat, collaborative docs, etc.) decoupled from reputation and group culture metrics (e.g. entry and exit rules, engagement incentives, likes or claps, visibility and feed ordering); in social platforms on the centralized web, these distinct functions are typically combined. To facilitate neighbourhoods, we are building a language and “interchange” for reputation data on Holochain such that users can connect a portable reputation extension to bundles of Holochain groupware.

Groups can then use the neighbourhoods framework to bundle p2p modules with reputational and cultural inputs that relate to their particular use cases and style of relating. This also means individuals’ reputation and activity records are stored on their devices, and so can be ported to other neighbourhoods and verified using Holochain’s gossip protocol for data validation. Neighbourhoods is centered on the Holochain ecosystem, but it may also be of interest to dWeb communities and projects aspiring to traffic in “richer” data than ownership claims & token counts - especially when those data support community collective intelligence.

Much of the system remains to be built, but the core language - rep_lang - has been integrated with Holochain. We’ll close with a brief demo showing one key aspect of the system: rep_lang computations being validated by multiple agents on Holochain.

Metaprogramming in Nim is very powerful. But why would you use it? How is it used in the real world? We will explore the "power levels": starting from generics, continuing to templates and finally arriving at macros.

We will first look at generics usage in VMath (Vector Math Library) and Jsony (JSON Parsing Library). Then we will continue on to templates and how they are used in VMath and Windy. Finally we will look macros, the top of the "power levels", and how they are used in Shady (a Nim to GLSL compiler) and Genny (Generates bindings for Nim libraries).

Time has come to rewrite our system software in Rust and leave the pitfalls of C behind. This also includes basics such as filesystem support. I took on the challenge to implement NTFS, the primary filesystem used by Windows, in a Rust crate that is equally usable from the firmware level up to user-mode.

While Rust has been conquering the system software landscape for the past few years, there are next to no examples for implementing filesystems. Likewise, NTFS only has a single major open-source implementation known as ntfs-3g, and it was developed in C over a decade ago.

This talk will cover my motivation for targeting NTFS and various use cases for such a Rust crate. I will introduce you to the internals of the NTFS filesystem, how they influenced the crate's design, and how Rust's features can be leveraged to create a safe and maintainable implementation. My talk will cover the current implementation, but also the necessary iterations until I got there. Finally, we will also deal with the current limitations of the Rust ecosystem and possible future improvements to the crate.

You will see that Rust has many advantages for implementing filesystems, and I hope to see more such crates in the future.

An introduction (live demo with questions and answers) into RPort - a new open-source software for remote access and remote management of heterogeneous it-landscapes. Use the UI, the command line or an REST API to manage servers and desktop efficiently from a central place.

RPort is a comprehensive solution for remote management of servers and desktop systems. Even if they are behind firewalls, routers and NAT. RPort is built on the client-server principle, clients connect to the server, the management component, using a secure reverse tunnel. Unlike pure SSH, RPort is made for heterogeneous environments (Windows, Linux, macOS) and addresses four basic needs of system administrators: • Secure remote access from anywhere via tunnels and SSH/RDP/VNC/HTTP and other TCP connections • Script and command execution on target machines via a central dashboard. • Automation of recurring tasks such as updates, inventory, configuration and fine-tuning of systems. • Monitoring and logging system load and resource usage.

With RPort, a complete IT infrastructure with Windows, Linux and macOS systems can be managed via command line or a convenient web-based, central dashboard. The server component can be self-hosted or deployed in minutes using the automated installer provided by RPort. RPort is released under the MIT open-source license.

MYSQL_JSON plugin is created in MariaDB as a bridge to bypass the confusion between MySQL and MariaDB JSON data type representation and to help MariaDB users in that regard. Purpose of this talk will be to highlight how to convert MySQL data directory containing JSON native data type in MySQL to the MariaDB data directory where JSON is stored as an alias for LONGTEXT and how to deal with errors in that process.

As tech lead on commercial UNIX at Bell Labs, an opportunity arose in 1988 to write a nano-kernel to end all nano-kernels, complete with an unhackable boot requirement. It was clear that a cryptographically secure chip level boot assistance was required, which guided subsequent patented ECC work at NeXT and Apple. Post Apple, in a “Social Purpose” company of his own, work has continued to fully realize this dream. The 1988 nanokernel had no threads and delivered messages across upcall channels to a thread simulation, yet that was unsatisfactory. The social element of phishing etc. is now the most feared secuirity breach, and in new work, discussed, the complete solution space is described, in the first half. New hardware is underway, solving such issues as weak memory models.

In the second half of the talk, key lockless queuing primitives are discussed that form the basis fo a multi-core actor runtime (MART) to subsume most if not all duties of the executive. Far richer than a hypervisor, the executive manages memory in new manners, in a memory safe programmer nature. In practice, a single core actor runtime (START), running across 32, 64 arm, x86, and extensa cpu architectures is available. The language and runtime are destined to the Open Source world, unless the larger project, TheDew, makes file systems and databases obsolete in its first rollout, which will include unhackable identity. Ask: Join us!

The Sustaining open source design podcast has been hosting conversations about open source and design over the last year with designers of all kinds across the spectrum of open source software projects. From new to open source to long term contributors and from practicing visual designers to design researchers. We've spent over 30 hours in conversation with designers and we are coming together as hosts to discuss the main themes throughout these conversations in 2021 at FOSDEM 2022 with a look ahead to what might come up in 2022 for design in OSS.

This will be a conversation between hosts of the SOS design podcast: Eriol Fox, Georgia Bullen, Memo Esparza, Peace Omejeh and Richard Littuar

https://sosdesign.sustainoss.org/

N/A

Software development has been gradually shifting from monolithic to distributed containerized applications. Such applications are composed of components referred to as micro services. With the increasing number of micro services, it becomes increasingly difficult to understand how all the components communicate.

This is where Istio service mesh comes into play. Istio allows developers to manage and monitor network traffic between micro services and by providing features like mutual TLS, request retries or request circuit breaking. Vendoring these features from Istio helps keeping micro services focused on the actual application logic as they don't need to be implemented by the micro services. The IT industry has broadly adopted this architecture, but there are still plenty of legacy workloads running in virtual machines, which can't easily take the advantage of the features provided by service mesh. At least not until recently when KubeVirt introduced support for Istio service mesh.

Attendees of this talk gain insight into the concept of the Istio sidecar proxy. A short demonstration showing typical use case of Istio service mesh -- canary deployment -- is presented. Next, this talk explains subtle differences of network traffic routing between regular Kubernetes pods and containerized KubeVirt virtual machines, leading to the challenges that these differences pose for traffic proxying. Finally, the changes necessary to support Istio for KubeVirt virtual machines are explained and the resulting functionality presented using the same scenario, but with the workload running in virtual machines instead of Kubernetes Pods.

The takeaway of this talk is understanding of routing concepts behind Istio proxy sidecar with regular Kubernetes pods as well as with containerized KubeVirt virtual machines. Audience will have a chance to observe typical use case of Istio with both pods and virtual machines and get insight into the necessary changes that made this possible.

The experiments at the Large Hadron Collider (LHC) at CERN have been running for more than a decade. The data recorded by the detectors such as the CMS experiment are analysed by thousands of physicists all over the world. The CMS Collaboration has made openly available more than 2.5 petabytes of data on the CERN Open Data Portal, containing billions of recorded and simulated events.

Open Data are, however, only useful when accompanied by realistic usage examples. The sheer amount of data as well as the fact that the software used to analyse them is often more than ten years old poses several challenges. In this presentation, Clemens will discuss how the CMS Data Preservation and Open Access group tries to overcome these challenges so that potentially everyone could use the data to unveil hidden physics.

Fuzion is a modern general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects.

This talk will explain how Java's concepts such as classes, interfaces, methods, constructors, packages, etc. are mapped to the single concept of a Fuzion feature. The fzjava tool will be explained that provides Fuzion interfaces to Java libraries. Finally, the Fuzion interpreter and a (planned) Java byte-code back-end are presented.

Introduction

Fuzion is a modern general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects.

Fuzion was influenced by many other languages including Java, Python, Eiffel, Rust, Go, Lua, Kotlin, C#, F#, Nim, Julia, Clojure, C/C++, and many more. The goal of Fuzion is to define a language that has the expressive power present in these languages and allow high-performance implementations and powerful analysis tools. Furthermore, Fuzion addresses requirements for safety-critical applications by adding support for contracts that enable formal specification and enable detailed control over run-time checks.

Many current programming language are getting more and more overloaded with new concepts and syntax to solve particular development or performance issues. Languages like Java/C# provide classes, interfaces, methods, packages, anonymous inner classes, local variables, fields, closures, etc. And these languages are currently further extended by the introductions of records/structs, value types, etc. The possibility of nesting these different concepts results in complexity for the developer and the tools (compilers, VMs) that process and execute the code.

For example, the possibility to access a local variable as part of the closure of a lambda expression may result in the compiler allocating heap space to hold the contents of that local variable. Hence, the developer has lost control over the allocation decisions made by the compiler.

In Fuzion, the concepts of classes, interfaces, methods, packages, fields and local variables are unified in the concept of a Fuzion feature. The decision where to allocate the memory associated with a feature (on the heap, the stack or in a register) is left to the compiler just as well as the decision if dynamic type information is needed. The developer is left with the single concept of a feature, the language implementation takes care of all the rest.

Fuzion Feature Declarations

A Fuzion feature has a name, similar to the name of a class or a function. The main operation that can be performed on a feature is a feature call. The constituents of a feature declaration are as follows:

Formal Arguments

Features may have a list of formal arguments, which are themselves features implemented as fields. On a call to a feature with formal arguments, actual arguments have to be provided to the call, unless the list of formal arguments is empty.

Feature Result

The result of a feature call is an instance of the feature. Alternatively, a feature may declare a different result type, then it must return a value of that type on a call.

Closures

Features are nested, i.e., every feature is declared within the context of an outer feature. The only exception is the universe, which is the outermost feature in Fuzion. A feature can access features declared in its outer feature or, recursively, any outer feature of these outer features. This means, a feature declaration also defines a closure of the feature and its context.

When calling a feature f1 declared as an inner feature of f2, the call must include a target value which is the result of a call to f2, e.g., f2.f1.

Generics

Features may have generic type parameters. E.g. a feature declaration may leave the actual type used within that feature open and to be defined by the user of the feature.

The list of generic type parameters may be open, i.e., the number of actual generic type parameters is not fixed at feature declaration. This turns out to be useful in the declaration of choice types and functions as explained below.

Inheritance

Fuzion features can inherit from one or several other features. When inheriting from an existing features, all inner features of the parent automatically become inner features of the heir feature. It is possible to redefine inherited features. In particular, when inheriting from a feature with abstract inner features, one can implement the inherited abstract features.

A redefinition of an inherited feature may implement an inherited feature as a routine or as a field. An inherited feature that is implemented as a field, however, cannot be redefined as something else since fields might be mutable.

Inheritance may result in conflicts. An example would be two features with the same name that are inherited from two different parents. In this case, the heir must resolve the conflict either by redefining the inherited features and providing a new implementation or by renaming the inherited features resulting in two inner features in the heir feature.

Inheritance and redefinition in Fuzion does not require dynamic binding. By default, the types defined by features are value types and no run-time overhead for dynamic binding is imposed by inheritance.

A Contract

A feature may declare a contract that specifies what the features does and under which conditions the feature may be called.

An implementation

Features must have one of the following implementations

• a routine is a feature implementation with code that is executed on a call

• a field is a memory slot that stores a value and whose contents are returned on a call

• an abstract feature has no implementation and cannot be called directly, but can be implemented by heir features

• an intrinsic feature is a low-level feature implemented by the compiler or run-time system, e.g., the infix + operator to add two 32-bit integer values may be an intrinsic operation.

A feature implemented as a routine can contain inner feature declarations.

Feature examples

Here is an example that declares a feature point that functions similar to a struct or record in other languages:

point(x, y i32) is # empty
p1 := point 3 4
say "p1.x is {p1.x}"    # will print "p1.x is 3"
say "p1.y is {p1.y}"    # will print "p1.y is 4"

The next example shows a feature base that provides an inner feature plus that adds its argument to the value passed to the enclosing base:

base(v i32) is
  plus(w i32) => v + w

b1 := base 30
b2 := base 100
say (b1.plus 23)    # will print "53"
say (b2.plus 23)    # will print "123"

Fuzion FZJava Tool

Fuzion provides a tool fzjava that takes a Java module file and converts it into Fuzion features. In the spirit of Fuzion, Java's packages, classes, interfaces, methods, constructors, static methods and fields are all converted into Fuzion features. Java methods that may throw an exception are converted into features resulting in a choice type that is either the exception type or the result type of that method.

A few intrinsic functions in the Java interpreter back-end use Java's reflection API to access the corresponding Java code.

Basic approach

The FZJava tool converts each Java class into three Fuzion Features. Say you have a Java class as follows

package x.y;
class MyClass
{
  MyClass(String arg)
  {
   ...
  }
  void myMethod()
  {
  }
  void myStaticMethod()
  {
  }
}

This will be converted into a Fuzion feature x.y.MyClass that may not be instantiated directly:

Java.x.y.MyClass(redef forbidden void) ref : Java.java.lang.Object(forbidden), fuzion.java.JavaObject(forbidden) is

  unit myMethod is
    ...

This feature defines a Fuzion type x.y.MyClass and contains wrappers for the instance methods. It is, however, not permitted to directly create instances of this feature, which is ensured the forbidden parameter of type void (which makes this feature 'absurd', it cannot be called directly since void values cannot be created).

Additionally, a Fuzion feature containing features for static methods and constructors is generated as follows:

Java.x.y.MyClass_static is

  new(arg string) is
    ...

  myStaticMethod is
    ...

This Feature defines a unit type. Finally, a Fuzion feature returning an instance of this unit type is generated for convenience

Java.x.y.MyClass => x.y.MayClass_static

With this, the following code can be used to create an instance of MyClass within Fuzion and call myMethod and myStaticMethod of this class:

o := Java.x.y.MyClass.new "test"
o.myMethod
Java.x.y.MyClass.myStaticMethod

The counterpart to import a Java class in Fuzion would be to declare a field and assign the class' unit type value to it, i.e., the code above could be simplified as

MyClass := Java.x.y.MyClass
o := MyClass.new "test"
o.myMethod
MyClass.myStaticMethod

or even

mc := Java.x.y.MyClass
o := mc.new "test"
o.myMethod
mc.myStaticMethod

using mc as an alias of Java.x.y.MyClass. Note that since the value of field mc is a unit type, this assignment or any accesses of mc will not execute any code at runtime.

Small Example

Here is a example how Java code can be used from Fuzion:

javaString := java.lang.String.new "Hello Java 🌍!"                          # create Java string, type Java.java.lang.String
javaBytes  := javaString.getBytes "UTF8"                                     # get its UTF8 bytes, type is fuzion.java.Array<i8>
match javaBytes
  err error => say "got an error: $err"
  bytes fuzion.java.Array =>
    say "string has {bytes.count} bytes: $bytes"
    javaString2 := java.lang.String.new bytes 6 bytes.count-6                # create Java string from bytes subset,
    say "Hello "+javaString2                                                 # append Java string to Fuzion string and print it

Web Server Example

The following code shows how Java APIs can be used to create a minimalistic web server in Fuzion.

webserver is

   # declare short hands to access Java net and io packages
   net := Java.java.net
   io  := Java.java.io

   # open socket
   port := 8080
   serversocket := net.ServerSocket.new port
   match serversocket
     err error => say "#### $err ####"
     ss Java.java.net.ServerSocket =>

       for n in 1.. do
         say "accepting connections to localhost:$port"

         match accept
           unit      => say "ok."
           err error => say "#### $err ####"

         accept outcome<unit> is
           # accept and handle connection
           s := serversocket.accept?
           input  := io.BufferedReader.new (io.InputStreamReader.new s.getInputStream?)
           output := io.DataOutputStream.new s.getOutputStream?

           req := read?
           say "got request ({req.byteLength} bytes): $req"
           if req.startsWith "GET "
             (send200 "<html>Hello Fuzion $n!</html>")?

           # close streams
           input.close?
           output.close

           # helper to read request
           #
           read outcome<string> is
             for
               r := "", "$r$s\n"
               s := input.readLine?
               ready := input.ready?
             until s = "" || !ready
               r

           # helper to send data in HTTP response with status 200
           #
           send200(data string) outcome<unit> is
             output.writeBytes ( "HTTP/1.1 200 OK\n"
                               + "Connection: close\n"
                               + "Server: Fuzion demo WebServer v0.01\n"
                               + "Content-Length: " + data.byteLength + "\n"
                               + "Content-Type: text/html\n"
                               + "\n"
                               + data)?

Java methods that may result in an exceptions are represented by Fuzion features that result in the type outcome<T> where T is the Fuzion type corresponding to the Java result type of the method. outcome is a union type that may be either error, which wraps the Java exception, or the actual result type T.

Java methods that result in void are mapped to Fuzion features that result in unit, or, outcome<unit> in case the method has any declared exception.f

Fuzion Interpreter

Fuzion currently supports two back-ends: An interpreter implemented in Java and running on top of OpenJDK and a C code generator implemented in Java using clang to create machine code.

The goal of the interpreter was to quickly obtain a way to execute Fuzion applications. Performance was not the main concern. The interpreter operates directly on Fuzion's abstract syntax tree.

For better performance, a byte-code back-end is planned that will operate on Fuzion's intermediate code instead.

Fuzion Byte-Code Back-End

Similar to Fuzion's C back-end, the byte-code back-end is planned to work on top of Fuzion's intermediate code.

Fuzion intermediate code

Fuzion uses intermediate files during different stages of compilation: module files that contain library code, application files for whole applications and Fuzion intermediate representation files that serve as input to the back ends.

Fuzion uses a simple intermediate code to represent pre-compiled modules and whole applications. This intermediate code serves as the input for static analysis tools, optimizers and for different back-ends that produce executable applications. The goal in the design of the intermediate file format was high performance and simplicity for tools using this code.

The intermediate code is a binary format containing features and types in a way that may be mapped to memory and used directly, so overhead of parsing this format into an in-memory representation is avoided. In particular, if only parts of a pre-compiled module are used by an application, there is no need to read and unpack parts of the module intermediate representation that are not used.

For features containing code, a very simple stack-based format is used. There are currently only ten different instructions:

* Unit -- produce a value of unit type
* Current -- produce the current instance as a value
* Constant -- produce a constant value
* Assign -- perform an assignment to a field
* Call -- perform a call to a given feature
* Tag -- convert a value into a tagged value of a choice type
* Match -- match a choice type
* Box -- convert a value type to a ref type
* Unbox -- extract the value from a ref type
* Pop -- drop the top element from the stack

The intermediate code uses indices to refer to features and types within intermediate files. This means that lookup is very efficient, but it also means that a change in a library module requires recompilation of all dependent modules. Any incompatibilities would be found at compile time instead of resulting in something like Java's IncompatibleClassChangeError at run-time.

Instance Implementation

Fuzion instances should be mapped directly to instances of Java classes generated for the corresponding features. Fuzion fields should be mapped to Java fields and Fuzion routines to Java methods.

Fuzion instances that are accessed only locally by their defining features code, i.e., they do not live longer than their code is executed and they are not passed to any other features, might be optimized and implemented as Java methods using local variables instead of fields.

Call Implementation

Fuzion's support multiple inheritance similar to Eiffel. Java support multiple inheritance only for interfaces, so one way to implement dynamic binding in calls would be to define interfaces for every Fuzion feature and use the JVM's invokeinterface byte-code for calls.

A more flexible alternative might be to use invokedynamic to implement dynamic dispatch, but this will likely result in higher overhead compared to highly optimized invokeinterface implementations.

Conclusion and Next Steps

The Fuzion language definition and implementation are far from stable, but are getting closer to become useful. Big improvements come from the ability to pre-compile modules and from the foreign language interface for Java, which makes a giant code base accessible for Fuzion applications to build on.

Additionally, new projects such as the language server implementation for Fuzion by Michael Lill help by integrating Fuzion support in popular IDEs and editors.

Main points that are missing right now are

• a powerful standard library
• additional library modules for all sorts of application needs
• low-level foreign language interface for C
• actual implementations of static analyzers and optimizers
• highly optimizing back-ends
• garbage collection for the C back-end
• documentation, tutorials
• enthusiastic contributors and users!

Please feel free to contact me in case you want to use Fuzion or want to help making it a success!

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

We'll talk about new features and fixes in Go, new proposals for Go 2. All of the new things you might have missed.

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

Sometimes it is useful to share code across multiple kernels -- in projects like the Oniro door lock blueprint, for the typical use cases a Cortex-M CPU running Zephyr is more than sufficient, but using its functionality as part of a larger project makes using Linux on Cortex-A an interesting option. Can we find a way to maximize code reuse despite the very different GPIO APIs?

Sometimes it is useful to share code across multiple kernels -- we avoid doing the work twice. However, this might be complicated when one version is using Zephyr with a Cortex-M, and another Linux on a Cortex-A. We will explore this problem using an example of the door lock blueprint from the Eclipse Oniro project - an implementation of basic door lock functionality. For a typical use-case, a Cortex-M with Zephyr is more than sufficient, but we might also want to integrate the same application in a bigger one using Linux on a Cortex-A. Will we find a way to do so?

The product document intersects between product and non-product teams. The dependency on the product features is invariably high with the early adopters and existing user base.

Integrating with the non-product groups to understand the expected use cases, building scenarios with the product team with quality and security being implicit will be the objective of this information engineering operations group.

Imagine the user base is trying to figure out a mail-merge situation using Base and Writer modules. LibreOffice offers features to integrate with the modules to merge and generate compelling mails.

An authoritative multilingual guide to accomplishing the scenarios will take a whale of time to reach the user base. Treating it as a lost opportunity, the new paradigms to integrate with the non-product and product teams will table the perspective of mirroring DevSecOps.

This talk will highlight the opportunities available within the industry for the Information Engineering team.

Is a decentralized metaverse with hundreds of millions of users possible? From my experience working on open source tools with over a half billion downloads in a year, the answer is yes. But not through blockchains, tokens, or gimmicks. This talk is for the pure hearted, those who want scale, security, speed, and small code. I'll first briefly cover some mind blowing demos that our community, GUN (a p2p Firebase), has achieved, then showcase a new way to make apps & games that can instantly render user data (without login or registration) without the app itself being able to access it (preventing apps from being able to mine or spy on your data).

In today’s cloud-first world, data security is still a major concern. Confidential computing addresses this at the root by protecting data in use: sensitive workloads are run inside hardware-isolated and runtime-encrypted environments called enclaves.

We have developed the first open-source database based on MariaDB designed for confidential computing. EdgelessDB is a MySQL-compatible database that runs entirely inside Intel SGX enclaves.

In this talk, we'll introduce EdgelessDB and compare it to conventional databases as well as existing database encryption solutions. We'll explore the benefits, novelties, and why confidentiality is an important feature of a database. Finally, you'll learn about uses cases and how to easily get started.

In this session, FOSS projects as given time to present and ask for contributions to the designers in the room. Each project is given 2 minutes to present. In those 2 minutes, they should briefly introduce the project, explain what design help they need, and provide contact details so designers can reach them after FOSDEM.

The Open Source Design collective will use the information to submit a "job" for each project to the Open Source Design "jobs board" (https://opensourcedesign.net/jobs/), so that the request for design help reaches not just the designers in the room, but also the wider design community.

Discussion between the Open data Panel speakers.

Many scientific disciplines have benefitted from the availability of big datasets to develop algorithm supported solutions. Recently, this trend has penetrated the fields of crime and police research. The presentation highlights use cases of big data computation and HPC for typical datasets in crime science: crime records, emergency call data, and police GPS data. The focus lies on spatiotemporal applications (i.e., geocoding, map matching, spatial and temporal algorithms). The datasets come from a collaborative project with a Belgian police force and encompass approximately 200,000 crime records and 400 million individual GPS datapoints (x and y coordinates + timestamp). The project aims at establishing the crime preventive effect of police patrols through a longitudinal research design. Besides offering novel computational solutions for crime scientist, these kinds of datasets introduce important ethical considerations as well as potential biases in human-led data entry and collection. These considerations underline the need for social scientists to become more literate in the computational sciences and support the framework of ‘crime science’ as a discipline of exact methods and data sources.

Many scientific disciplines have benefitted from the availability of big datasets to develop algorithm supported solutions. Recently, this trend has penetrated the fields of crime and police research. The presentation highlights use cases of big data computation and HPC for typical datasets in crime science: crime records, emergency call data, and police GPS data. The focus lies on spatiotemporal applications (i.e., geocoding, map matching, spatial and temporal algorithms). The datasets come from a collaborative project with a Belgian police force and encompass approximately 200,000 crime records and 400 million individual GPS datapoints (x and y coordinates + timestamp). The project aims at establishing the crime preventive effect of police patrols through a longitudinal research design. Besides offering novel computational solutions for crime scientist, these kinds of datasets introduce important ethical considerations as well as potential biases in human-led data entry and collection. These considerations underline the need for social scientists to become more literate in the computational sciences and support the framework of ‘crime science’ as a discipline of exact methods and data sources.

The talk provides an introduction to the corundum project, implementing a 100 GbE NIC based on Commercial-off-the-shelf (COTS) FPGA cards, e.g. Xilinx Alveo Cards. The project consists of all necessary RTL components, e.g. PCIe DMA engine, NIC datapath, MAC, PHY and integration of vendor specific IP cores, such as transceivers and PCIe hard-IP cores. In combination with the provided driver and debugging utility the ready-to-experiment state just requires a supported FPGA card + compiler to kick-off playing with the project.

The existing state provides the platform for future In-Network Compute platform research, allowing for application logic to be balanced across hardware acceleration and software flexibility. The platform uniquely allows for experiments with lower layer protocols, e.g. PHY layer coding.

The talk concludes with an overview about short term and mid term goals of the project.

A summary of LibreOffice 7.3 Community new features, with a specific focus on interoperability with Microsoft Office documents

The devroom intro by devroom organization team!

Optimization problems are everywhere, from deciding which clothes to pack in our luggage (aka the knapsack problem), to selecting the tasks that will be worked during a sprint. Trying to solve these type of problems by hand is a tedious task often resulting in sub-optimal decisions.

In this talk, we'll understand how PostgreSQL recursive queries can help. Starting from the proper problem definition, we'll then explore how to build queries that call themselves recursively, what are the risks associated with this approach and safeguards we can set to optimise performances. Finally we'll demonstrate how two new features released in PostgreSQL 14 enable an easier handling of the recursive statements.

If you're into PostgreSQL and eager to understand how recursion works, this session is for you!

Flame graph is way to visualize profiling data that allows the most frequent code paths to be identified quickly and accurately. They can be generated using Brendan Gregg's open source programs on github.com/brendangregg/FlameGraph, which create interactive SVG files to be checked in browser. The source of profiling data does not really matter - it can be perf profiler, bpftrace, Performance Schema, EXPLAIN output or any other source that allows to convert the data into the expected format of comma-separated "path" plus metric per line.

Different types of Flame Graphs (CPU, Off-CPU, Memory, Differential etc) are presented. Various tools and approaches to collect profile information of different aspects of MySQL server internal working are presented Several real-life use cases where Flame Graphs helped to understand and solve the problem are discussed.

Like most developers, I'm against my will a volunteer system administrator. I take care of my personal and professional notebooks. I also maintain a powerful build server at home and a remote VPS hosting my blog. From times to times I even use a single board computer to host some services.

A few years ago, all those machines ran different, dedicated Linux distributions: Ubuntu, ArchLinux, Debian, Raspbian, making the maintenance a nightmare. That was before diving into GNU Guix.

In this talk, I'll expose how GNU Guix, as an advanced package manager and Linux distribution can be advantageously used on any kind of machine from single board computers to VPS machines.

The declarative aspect of GNU Guix allows to have various operating system definitions inheriting from each other while the associate tooling such as "guix system" and "guix deploy" ease the deployment and upgrade tasks.

Opening!

LVGL is an open-source graphics library to create embedded GUI.

By its flexibility, this toolkit is well matching Oniro project's requirements to build a multiple kernel OS for IoT devices or enable interactions in a multiple devices environment.

UI toolkits are well established in CPU world (desktop, mobile), but what about in more constrained system ?

Often tied to one vendor, the choice is often limited. However OpenSource project LVGL provides everything developers need to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint.

This library is compact and flexible enough to be thread through a regular Linux system. Of course this will not compete with other popular frameworks like Qt or GTK, but it has some advantages worth sharing: where portability matters more than eye candy features.

Oniro's Bitbake recipes enable makers to build products with user interface in a Yocto environment that can target different kernels or graphics systems.

Oniro's blueprints will illustrate integration details to match a product requirement.

Demos of vending machine (running on Linux+Wayland) or keypad (on Zephyr MCU OS) will be shown too.

Fed up with managing your host OS for your docker environment? Try booting your containers directly from a light-weight initramfs! Flash a USB pendrive with the kernel and initramfs, or netboot it locally or from the internet, configure it from the kernel command line. Bonus: It also supports syncing volumes with S3-compatible cloud storages, making provisioning and back-ups a breeze!

Containers have been an effective way to share reproducible environments for services, CI pipelines, or even user applications.

In the high availability world, orchestration can then be used to run multiple instances of the same service. However, if your goal is to run these containers on your local machines, you would first need to provision them with an operating system capable of connecting to the internet, and then downloading, extracting, and running the containers. This operating system would then need to be kept up to date across all your machines which is error-prone and can lead to subtle differences in the run environment which may impact your services.

In order to lower this maintenance cost and improve the reproducibility of the run environment, it would be best if we could drop this Operating System and directly boot the containers you want to run. With newer versions of podman, it is even painless to run systemd as the entrypoint, so why not create an initramfs that would perform the simple duty of connecting to the internet, and download a "root" container which can be shared between all the machines? If the size could be kept reasonable, both the kernel and initramfs could then be downloaded at boot time via iPXE either locally via PXE or from the internet.

This is with this line of reasoning that we started working on a new project called boot2container which would receive its configuration via the kernel command line and construct a pipeline of containers. Additionally, we added support for volumes, optionally synced with any S3-compatible cloud storages.

This project was then used in a bare-metal CI, both for the test machines and the gateways connecting them to the outside world. There, boot2container helps to provide the much-needed reproducibility of the test environment while also making it extremely easy to replicate this infrastructure in multiple locations to maximize availability.

Continuous Delivery is all about getting your software released, and as software/system complexity continues to increase, so does the need to have many different tools, services and even people involved in building, verifying, deploying and monitoring your software. So, how do we make all these tools and services work together to complement each other without creating a massive spider web of explicit interconnectedness? CDEvents!

In this talk, Andrea Frittoli and Erik Sternerson will present the CDEvents project and protocol from the Continuous Delivery Foundation, describe how events in continuous delivery will help build a strong toolbox of CI/CD tools that can be used for delivery of different types of software projects, and showcase some integrations done by the community.

The number of tools and services supporting CI/CD keeps growing. Each tool has its own strengths and enables its own unique use cases. It is not one-size-fits-all, every project needs to be able to select CI/CD tools according to their own needs.

What CDEvents aims to do is to give these tools and services an obvious way to become interoperable through a shared event/messaging protocol, so that true end-to-end continuous delivery pipelines and processes with associated monitoring, metrics and insights can be built without the need for “manually gluing things together”.

Having the freedom to add and replace CI/CD tools and services without needing to worry about compatibility and interoperability issues will help projects keep their delivery processes optimized, and will also enable a new kind of visualization and monitoring tools that can inspect and understand all actors in the CI/CD system without explicitly knowing any of them.

The Matrix core team is busier than ever, juggling hundreds of Matrix Spec Core Proposals and undergoing some major techtonic shifts as Matrix evolves into the ultimate secure decentralised communication network. In this talk, we'll give a high-level survey of the state of the core project, including: * How we're ensuring that flagship clients are as attractive as possible to a mainstream audience - and why we will fail if we don't. * How we're making Matrix go fast via v3 sync and fast room joins * How matrix-rust-sdk is becoming a flagship client SDK * How we're getting a full end-to-end security of the reference Matrix stack * How we're tackling abuse on the public Matrix network * How Matrix is evolving to use cases beyond chat.

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

This year marks the first edition on which the devroom takes place on an online format. For that reason, this presentation will explain how does it work and how can the public use the systems provided by FOSDEM and interact with the speakers. We will also introduce the Ada-Europe and Ada-Belgium organisations. This small introduction also serves as a test to make sure the systems are working as expected and that any questions that may take place from the public can be answered.

Welcome to the Declarative and Minimalistic Computing Devroom.

In this year's virtual conference we will honour the late Professor John McCarthy as the founder of AI and the inventor of LISP. McCarthy with his work pioneered artificial intelligence, developed the Lisp programming language family and kickstarted our modern computing world. Lisp is one of the two oldest computer languages in use today.

ScummVM reached a milestone with the release of 2.5.0. Version 0.0.1 was released 20 years ago. The latest release was also the first release that included support for a few Director games.

MacroMedia Director, later Adobe Director, was a multimedia application authoring platform. Its ease of use led to a huge number of graphic adventure games being written with it. This was the late 90's. Some well known games are the Journeyman Project, Total Distortion and Spaceship Warlock.

One challenge to over come was to work on the code without breaking other parts. We'll go over the architecture of ScummVM, dive deeper into the Director Engine and land on how tests improved the code.

The FOSS Communities have been debating how to manage security, sustainability and funding of FOSS for years but today a global and political lens is being shone on them.

Commercial debates over licensing and revenue models around FOSS based businesses peak in 2021 with the Elastic transition away from FOSS to an SSPL licence and the fallout and debate from this.

The European Commission's Digital Decade is clear that its basis will be a FOSS infrastructure and Europe has been passing laws and regulations to support its open first approach, as it seeks digital and data sovereignty.

The inevitable success and adoption of FOSS in our national infrastructures and recent security issues have the minds of Governments focused on FOSSS, to the extent that the White House plans a meeting to discuss FOSS security in January having issued an ordinance recommending the use of Software Bill of Materials.

China's Ministry of Industry and Information Technology has shared a 5 year software plan saying "software defines the world of the future, open source determines the future of software," as it plans global collaboration to improve its open source activities.

In the UK, hosting COP26 shone a spotlight on energy and the UK Energy Sector Digitalisation Task force which has already suggested Open Data, will consider the use of open source software by default in its recommendations to Government in January. Whilst the NHS' data strategy issued in 2021 requires that open source software should be the default in healthcare.

This talk will stitch together these global threads, laws and policies to take a holistic view on the insurmountable success of FOSS in the last decade and the inevitable challenges being faced as a consequence of that success and the very nature and heart of FOSS in the Commons.

Sharing some policy suggestions and thoughts this talk will consider whether it may be time to shift the landscape. Is 2022 the year to recognise the need for FOSS to be characterised as a public good and to secure the interaction not only of business but of the State in funding and securing FOSS in the long term? How can this ensure sustainability of FOSS through its maintenance and sustainability of the planet by elevating the role of FOSS within environmental sustainability?

With a deep consideration of recent economic and policy discussions this keynote talk with pull many strands together to start 2022 with a focus on FOSS, funding and a secure and sustainable future.

Peergos gives users total control over their data. That means: Where it is, Who can see it, Who can't see it.

Used as a global file system, Peergos provides a private space where you can store, share and view your media and documents. Individual content can be shared outside peergos via secret links and whole static sites can be hosted via a gateway.

Used as an application platform, Peergos provides productivity tools like a calendar, todo/project boards and document viewer/editors. In the near future users will be able to add their own applications using the same secure application protocol.

Used as a communication platform, Peergos provides a social media feed, group chat and an email bridge.

Peergos is open source and self-hostable.

This talk with introduce Peergos. It will expand on the project's goals, its architecture and some of the technical details. It will provide a walkthrough of the current functionality and a sneak-peak of what the future may hold.

Apache Kafka is recognised as the best data streaming platform around, but it can be difficult to observe what is happening when you are just getting started with this excellent technology platform. In this session, you will get a tour of key Kafka features using the delightful web UI of Jupyter notebooks.

Use the notebooks to see Kafka and Python in action, producing and consuming records. We’ll also cover how to get the best from your application by making good use of topic partitioning and consumer groups. From high-level concepts to nitty-gritty details, this session will equip you with the skills you need to build applications with Kafka. Recommended for anyone curious about Apache Kafka or using Jupyter to work with or learn new data platforms.

Currently, operating systems have become increasingly complex and thus more sensitive to security problems and performance issues. In some circumstances, developers have to reboot their systems in order to patch security vulnerabilities, fix bugs, and add new features, which will bring unavoidable downtime for running applications. Live-patch is an elegant solution. But, it can only work in 30 percent of circumstances. In our project, we put another solution into practice. We use a checkpoint-and-restart mechanism to retore applications' status and then switch the kernel fastly.

speech

speech

Welcoming participants to the virtual edition of the Kotlin DevRoom @ FOSDEM

Currently, to access storage, many different type of Volume Plugins are used. But many of them like "FlexVolume" and "In-tree" are either OLD, or deprecated.

In our talk, we wish to discuss the solution of the same, by sharing information about the different types of volume plugins; and demonstrating the migration procedure from deprecated plugins to the latest "CEPH-CSI"(https://github.com/ceph/ceph-csi); with a pre-recorded demo of the same.

Enhancing diversity and inclusion in every aspect of technology is an essential conversation everyone should be a part of. In an increasingly interconnected world, we have a shared responsibility to ensure technology is a force that works to benefit everyone, countering structural sources of inequity where needed.

This session aims to jump start your personal diversity and inclusion journey by explaining the basics in simple terms with relevant examples for technologists. Concepts covered will include unconscious bias, privilege, equity, allyship, covering and microaggressions.

Package URLs are a compact way to identify software packages across multiple ecosystems. Together with the new "vers" Version Range Specifier, these two mini specs will offer a new way to create new, mostly universal dependency resolvers and installers, working across ecosystems.

Because no tech stack is an island running on a single programming language and in a single package ecosystem, we need a way to talk about packages across ecosystems: talk about their type, name, location, version and dependent version ranges. purl and vers are an attempt to solve this problem.

How to talk about packages, dependencies and vulnerabilities using a common language?

I will present Package URL, a way to references package across ecosystems which is emerging as a de-facto standard. And I will introduce a new work-in-progress, mostly universal notation to express version ranges to be used in resolving package dependencies such as "I require package foo, version 2.0 or later versions" and referencing affected vulnerable packages versions as in "vulnerability CVE-123 affects package bar, version 3.1 and version 4.2 but not version 5".

These two will show a way to create new, mostly universal dependency resolvers and installers, working across ecosystems and we will promote the rise of universal package managements where one tool and one unified spec can rule them all.

In 2021 Kotlin turned 10 and the team delivered 2 major releases (1.5.0 and 1.6.0) and a few minors. The main themes of those releases were Java interoperability and consistency of the language features. Meanwhile, Kotlin/JS has been promoted to Beta and KMM is on its path to reaching Beta status as well. However, one long-running project in Kotlin is the development of the new compiler, K2, which should set a solid foundation for the language and the ecosystem for the years ahead.

This session is an overview of the latest developments in Kotlin: the language, tools, compiler, and the ecosystem around it. We're also going to take a look at Kotlin's roadmap to see where are we heading. Come and learn what's new and exciting!

In this session, we’ll see why we adopted OpenTelemetry & its collector for an internal platform at Ubisoft - to collect/process/export all our logs, metrics, and traces. We’ll explain how we handled the required mindset change: why people should instrument more their code, and how to onboard them. And of course, we’ll talk about the benefits of fully adopting OpenTelemetry.

The intended audience is people who want to adopt OpenTelemetry, or who are already using part of it - for example the SDK for tracing - and are considering a full switch.

The Qualcomm Snapdragon 410 (msm8916) is a SoC that was used in many smartphones and tablets around 2015. It is the most mature "aftermarket" platform postmarketOS can offer at the time of writing. Many of the supported devices are quite usable and have most of the expected features like phone calls and mobile data working.

The talk goes over some of the most important challenges that we have faced while supporting those devices and describes the ways in which we have solved them.

Apart from the Linux kernel, we focus on various other tools and projects like lk2nd - a shim bootloader that prepares the environment for booting Linux and hides some device-specific quirks from the kernel. It also unifies the boot and installation process on all devices.

We also have other tools and resources to make porting easier. Those include various documentation or even a fully automated display driver generator that helps with the fact that each display requires unique initialization.

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

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

Metaprogramming is a technique that allows the creation of data and control structures during runtime. This gives adaptiveness and expressiveness to languages, allowing the creation of data structures with complex behavior, and adapted to the environment or to the data used. In this talk we will talk about general metaprogramming techniques, with examples in Raku and other modern languages.

A brief introduction and overview of what you can expect from the Public Code devroom at FOSDEM.