With the end of Moore’s law, improving single-core processor performance can be extremely difficult to do in an energy-efficient manner. One alternative is to rethink conventional processor design methodologies and propose innovative ideas to unlock additional performance and efficiency. In an attempt to overcome these difficulties, we propose a compiler-informed non-speculative out-of-order commit processor, that attacks the limitations of in-order commit in current out-of-order cores to increase the effective instruction window and use critical resources of the core more intelligently. We build our core based on the open source RISC-V ISA. The hardware and software ecosystem around RISC-V enables building custom hardware and experimenting new HW/SW cooperative ideas.

While modern out-of-order processors execute instructions out-of-order to increase instruction-level parallelism, they retire instructions and manage their limited resources (register file, load/store queue, etc.) in program order to guarantee safe instruction retirement. However, this implementation requires instructions to wait for all preceding branches to resolve in order to release their critical resources, which leaves a significant amount of performance on the table. We propose a HW/SW co-design that enables non-speculative out-of-order commit in a lightweight manner, improving performance and efficiency. The key insight of our work is that identifying true branch dependencies, if properly understood, could lead to higher performance. Dependency analysis shows that not all instructions depend on the most recent branch in the reorder buffer and therefore, there are missed opportunities to improve the performance by not releasing the critical resources of independent instructions. Our processor employs a HW/SW co-design where the compiler detects true branch dependencies that enables the hardware to manage critical resources more intelligently. Also, we introduce a new interface between hardware and OS to enable precise exception handling by exposing recent changes of out-of-order committed instructions.

In our talk, we will look at the potential of our out-of-order commit core for HPC workloads. Initial studies with C-based HPC applications show promising results, and we intend to show results for a variety of additional HPC workloads to evaluate the potential of the design. We believe our HW/SW co-design might be a way to build the processors in the future. This work will appear in proceedings of the 26th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS 2021).

KubeVirt enables developers to run Containerized Application and Virtual Machines in a common, shared Kubernetes/OKD/OpenShift environment. An Operator is a method of packaging, deploying and managing a Kubernetes/Openshift application. The Hyperconverged Cluster Operator is an unified operator deploying and controlling KubeVirt and several adjacent operators in a controlled and opinionated way.

KubeVirt enables developers to run Containerized Application and Virtual Machines in a common, shared Kubernetes/OKD/OpenShift environment. An Operator is a method of packaging, deploying and managing a Kubernetes/OKD application. The Hyperconverged Cluster Operator is an unified operator deploying and controlling KubeVirt and several adjacent operators such as: - Containerized Data Importer - Scheduling, Scale and Performance - Cluster Network Addons - Node Maintenance - VM Import

The Hyperconverged Cluster Operator delivers the domain-specific knowledge needed to orchestrate and automate the deployment and the upgrades of Kubevirt and its sibling operators in an opinionated and managed way. The Hyperconverged Cluster Operator can be installed on bare metal server clusters an a matter of minutes, even from a GUI, without requiring a deep knowledge of Kubernetes internals. The Hyperconverged Cluster Operator can be easily deployed in combination with rook.io to provide cloud native virtualization and distributed self-managing, self-scaling, self-healing storage services on a single cluster.

An attendee will learn: - quick intro to KubeVirt technology (virtualization add-on for Kubernetes) - how to deploy and maintain it with the Hyperconverged Cluster Operator (deep-dive) - ongoing development and how to contribute

How can users of your network be allowed not only to remotely access their files but also to collaboratively edit them? Docker, NextCloud, LibreOffice Online and LDAP are the pillars of the proposed solution. The talk will start describing the context where this proposal was born i.e. the FUSS Project (https://fuss.bz.it). The analysis of the problem will follow along with the development details of the solution and suggested deployment strategies.

FUSS is both a digital sustainability project launched back in 2005 and a GNU/Linux, Debian-based distribution for schools, currently used in around 80 schools in northern Italy’s South Tyrol. The presentation, held by Paolo Dongilli (FUSS Project coordinator) and Marco Marinello (developer) will quickly go through the first 15 years of life of the project and then deeply inspect the proposed solution called "FUSS Remote Access" which helped teachers accessing their didactic materials and files left in schools' servers during lock-downs caused by the Covid-19 pandemic.

Having been an advocate of free (as in freedom) communication systems for almost as long as I've been on the internet, the number of people I successfully converted away from proprietary networks was surprisingly low for a very long time.

In this talk I will share the lessons I have learned while trying to implement (Prosody/Snikket), document (modernxmpp.org) and promote communication freedom to people.

A warm welcome from your devroom managers, practical information, lineup and administrivia. Let's make this edition of FOSDEM count!

Happy Testing!

A brief introduction to the 2021 virtual FOSDEM devroom, talk overview, code of conduct and Community Affairs Team.

Please ask any questions after the introduction - there will be 10 minutes for discussion.

TPF Code of Conduct applies to our devroom

Welcome talk and introduction to the Microkernel Devroom at FOSDEM 2021.

While we all probably think we're doing all the DevOps stuff the right way (and we do, don't we?), drift happens. Even as an experienced Terraform user, as your infrastructure team and codebase grows, it often becomes harder to track drift. I'll share here war stories from different teams, and show common pitfalls of popular commands we use when we want to know what's changed in our infrastructures.

While we all probably think we're doing all the DevOps stuff the right way (and we do, don't we?), drift happens. Even as an experienced Terraform user, as your infrastructure team and codebase grows, it often becomes harder to track drift. I'll share here war stories from different teams, and show common pitfalls of popular commands we use when we want to know what's changed in our infrastructures.

There are a lot of juicy stories from the trenches to be told on infrastructure drift.

Sure enough, we all do GitOps by the book! Or we all have the right processes in place. But we also have to interact with other teams. We also have to grant some level of access to our infrastructures to some services or tools that may eventually generate uncontrolled changes. What if we couldn't catch them all? What if all drift reporting so far was faulty?

You can't efficiently improve what you don't track. We track coverage for unit tests, why not infrastructure as code coverage? How can we make sure our infrastructure code matches our actual infrastructure state? In this talk, using Terraform with AWS resources, I will show how infrastructure drift can go undetected despite our best efforts or tooling and cause issues and end the talk by showing our own tool driftctl, (just released under Apache-2.0 licence) that tracks IaC coverage and warns of infrastructure drift.

Java is changing faster than ever with new features being added every six months.

Despite being over 25 years old, Java is still adapting to ensure it remains one of the most popular platforms on the planet. Find out in this session how to take advantage of many of these exciting new features.

With the release of JDK 16, we will have had eight (yes eight!) versions of Java in less than four years.

We still hear claims that Java is the new COBOL, and its popularity is in decline. The reality, however, is that Java developers are now being provided with new features at a faster pace than at any time in its 25-year history.

Many of these new features provide exciting new language level changes, as well as useful new APIs.

In this session, we’ll explore in detail what these changes are and how best to use them (as well as advice on when not to use them). We’ll also explain the significance of preview features and incubator modules.

We’ll cover the following new language features:

• Local variable type inference (JDK 10)
• Switch expressions (JDK 12)
• Text blocks (JDK 13)
• Records (JDK 14)
• Pattern matching for instanceof (JDK 14)
• Sealed classes and changes to Records (JDK 15)

For each of these JDKs, we’ll also highlight the most useful additions to the core class libraries and changes in the HotSpot JVM.

At the end of this session, you’ll be all set to write modern Java code!

A brief introduction to the room and to the sessions.

This year's TEE devroom will 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-12h35: Enclave shielding runtimes and programming paradigms

featuring Enarx, VeraCruz, OpenEnclave, Graphene-SGX, Rust-EDP, and Sancus

12h35-13h30: Lunch break & buffer 😋

13h30-14h45: Attacks and reverse engineering

featuring VoltPillager, SEV-ES, and ARM Secure Boot

14h45-15h00: Coffee break & buffer ☕️

15h00-16h40: Emerging RISC-V TEEs

featuring Penglai, Keystone, TEEP, and Trusted RV

16h40-16h50: Coffee break & buffer ☕️

16h50-18h00: Alternative trusted-hardware extensions

featuring CHERI, Cubicle OS, and HLS

This will be an introduction to the OpenPOWER DevRoom, it will briefly explain the OpenPOWER Foundation, the changes we're making and how we want to interact more with the open source communities, for both hardware and software. And introduce the DevRoom for the day.

The Interpeer Project attempts to provide the technical underpinnings for a human centric next generation internet.

As sensors and compute nodes are now (close to) ubiquitous, it follows that there is no longer a static or traceable relationship between ownership of a physical processing unit and the personal identifiable data it processes.

A future internet architecture must take this into account, whilst respecting and protecting user's privacy and data protection concerns, also from a regulatory point of view. At the same time, sharing data in this proliferation of processing units also favours distributed approaches over the web's decentralised architecture.

This session outlines the future the Interpeer Project envisions, and reports on achieved outcomes to date.

The Web has was designed with sharing of textual information in mind, and has by now outgrown this purpose. In the academic context in which it was conceived, and considering the technical constraints of the time, it made sense to design a centralised protocol for up- and downloading documents to a server managed by an institution or company. The Web has long evolved away from this, and added authentication, authorization and encryption as natural afterthoughts to the original design.

Nowadays, we share more than documents. Our concept of sharing has evolved (for better and worse) from only adding to the public domain to selectively trusting groups or individuals with specific pieces of information.

While services built on web protocols can and have modelled this new concept, it remains difficult to do well. This and financial incentives combined push developers to instead adopt half measures, whereby a central instance - the webserver and its legal owners - act as intermediaries to the process, weakening the sharing model to commercial, state or criminal exploitation.

There are excellent organisations fighting to amend legislations to close such loopholes. The Interpeer Project recognizes that aside from the legal struggles, the practical consideration remains that it is much simpler for developers to build centralised, vulnerable products than those safe by design.

It aims at making safe data sharing applications as easy or easier to build by starting from the ground up, and embedding the security and synchronization concepts for a highly distributed network directly into a new and open protocol stack.

Empowering users in the context of this project means enabling them to do everything they're currently used to and more, but safely and without the strict need for centralised infrastructure.

As technology advances, so as our maps. In this talk, we will explore the ever growing open map data that can help us understand, validate, and explore socio-economic indicators with the aid of network theory and machine learning techniques.

Participants will learn what data are available in OpenStreetMap that can be used to profile cities and municipalities for socio-economic conditions based on proxy variables. These variables include existence of businesses through establishments and buildings, road network densities and complexities, topographical features, vegetation and water indices, etc. Machine learning models will be used for categorization aided by graph metrics. Results will be cross validated with existing city/municipality tags.

The open source emulation landscape is littered with abandoned projects. MAME has survived stock market crashes, a pandemic, major internal refactoring, half a dozen leadership changes, and persistent rumours of the project’s imminent death. Why is MAME still here? How does MAME continue to attract contributors? What are some of the issues a project this size faces?

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

A brief introduction to the room and to the sessions.

A brief introduction to the room and to the sessions.

Fluence is an open application platform powered by peer-to-peer computing protocol and a decentralized licensing system. Fluence enables developers to host applications in the decentralized network and collaborate on live applications, reusing components and data. The protocol creates an open marketplace of compute capacity, so availability and pricing are not controlled by a single company and instead are driven by competitive market forces.

Applications are faster to build, easier to integrate, and more secure due to the enhanced composability. Business logic is incorporated into data packets orchestrating the execution of distributed components. Just as code collaboration creates better products, composition via network protocol enables live apps to be forked, expanded, or re-arranged into new and enhanced user experiences.

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

FOSDEM would not be FOSDEM without waffles... What if we coud use Postgres to make waffles ?

During this talk we will use the excuse of FOSDEM and Brussels to create an extension that will look for the best waffle recipe and use Postgres to display it. During this journey, on top of making delicious waffles, we will : - understand what an extension is - find the steps needed to create an extension - make this work all together - install our extension - display the best Waffle recipe

In March 2021, OpenNMS will celebrate its twenty-first year as a free software project. Much has changed since the early days, both within the project and in the world in which people build and monitor networks. Surprisingly little has changed with respect to the project's mission, even as major changes are happening with the project's corporate steward, The OpenNMS Group.

Newcomers will receive a brief background on the OpenNMS project, and longtime users will come up to date with the project's latest advancements and near-term plans. If you're interested in monitoring your networked resources with a free platform that integrates events, metrics, flows, ML-enabled correlation, and more in a multi-protocol, distributed, and fault-tolerant model, this talk might be for you.

MariaDB Corporation is currently working on plenty of features for MariaDB 10.6. At the same time we already have a long list of things to add in future versions of MariaDB. This talk will look at the main tasks for 10.6 and future versions of MariaDB. At the same time we are hoping to get feedback and suggestions from the community

If you’re designing a project where security is uppermost, but you want to make it easy to use and compatible with multiple platforms (existing and future), what principles should you follow, and how do they translate into an architecture and actual code. We’ll present the 10 security design principles of the Enarx project, and discuss why they led us to where we are today: a Rust-based open source project with a WebAssembly run-time.

I will provide an update on developments in the seL4 ecosystem in the past 12 months. Highlights include the creation of the seL4 Foundation and some of its activities since, and the functional correctness proof of seL4 on the RISC-V architecture. I will also discuss our work on time protection, a principled and systematic approach to prevention of timing channels and on-going work on its formal verification.

KernelCI has now been a Linux Foundation project for just over a year. During that time, it has set the basis needed to fulfil its mission of being the de facto upstream kernel test system. We can now build many more kernels, run many more tests and collate results from many more test labs. We also have a growing team of core contributors, an on-going commitment from our member companies as well as more presence in the kernel community. Together, we are gathering the momentum needed to start a trend.

Now we need to make KernelCI a natural part of upstream kernel development and realise its true potential. The Community Survey in June 2020 showed there is great value and interest in having a more test-driven workflow. While this is going to be a long-term goal, we already have a process to let the community shape the KernelCI tools according to their own needs. This talk gives an overview of how it would work, essentially by allowing decisions to be based on feedback from the whole ecosystem (developers, maintainers, OEMs...). We want to hear from you!

Microwatt is an open-source POWER CPU implementation which can run on cheap FPGAs, bringing new level of accessibility to POWER. In the last year, we have added to Microwatt features such as a memory management unit, privilege modes, interrupts, a floating-point unit, an interrupt controller and a level-2 cache, so that now it can boot Linux. This presentation will outline these new additions to Microwatt and talk about some interesting applications for Microwatt.

Microwatt is an open-source POWER CPU implementation which can run on cheap FPGAs, bringing new level of accessibility to POWER. In the last year, we have added to Microwatt features such as a memory management unit, privilege modes, interrupts, a floating-point unit, an interrupt controller and a level-2 cache, so that now it can boot Linux. This presentation will outline these new additions to Microwatt and talk about some interesting applications for Microwatt.

How to write Angular components that can evolve ? How can we write components that can easily be refactored ? How can we write tests that won't be useless as soon as we change the implementation ? We can achieve all that by writing the tests first, writing tests that are agnostic of the implementation, so writing tests that focus on features.

When it comes, refactoring an Angular component can be delicate especially if the refactoring breaks all existing tests. Adapting the tests while refactoring is always a risk, it can make the tests useless. So how can we write tests that aren't coupled to the implementation ? We can do it by writing the tests firsts, if there is no implementation, tests can't be coupled. Let's see how we can write theses tests without knowing how the component looks like.

Set operators are often seen as a way to handle (semi-)complex mathematical issues, the only exists in Set objects. But set operators are so much more! This presentation will show you how to make use of set operators in your day-to-day code, making your code more concise, better readable and better maintainable.

Matrix (https://matrix.org) is an open protocol for secure, decentralised communication - defining an end-to-end-encrypted real-time communication layer for the open Web. Historically the network has been made up of newly written native Matrix clients, or bridges to 3rd party existing chat systems (e.g. Slack, Discord, Telegram).

This year, however, we added production-grade native Matrix support for the first time to a major 3rd party chat system: Gitter (https://gitter.im) over the course of about 5 weeks. This talk will explain how we did it it, and show how easily other existing chat systems can extend their reach into the whole Matrix ecosystem; breaking open those walled gardens forever.

With the European Commission proposing to mandate interoperability for big tech "gatekeepers" (https://ec.europa.eu/commission/presscorner/detail/en/ip202347), it's never been more relevant to understand how best to expose existing communication silos via open communication APIs such as Matrix.

Between October & December 2020 we happened to go through precisely this process - designing how best to make Gitter natively speak Matrix such that Matrix users can natively participate in all Gitter conversations, using it as the reference example of linking an existing large-scale chat silo into Matrix. Do you try to natively speak the Matrix server-server API? Or do you embed a homeserver (if so, which one?) and use the Application Service API? Where do you store the data, and how do you minimise duplication between your existing service and Matrix? How do you scale to a userbase of millions of users? How do you handle end-to-end encryption?

In this talk, we'll answer these questions; and show how we're at the point where Matrix has matured enough that it could actually be used to add open communication APIs to the tech giants if they ever found themselves in need.

We will describe in this talk how to combine crowdsourcing approaches with scientific expertise in Digital Humanities projects, and some of the issues that are at stake. The talk will focus on Recital, a Digital Humanities project aiming at gaining insights on 18th-century theater through the analysis of its accounting books. It combines crowdsourcing, using the ScribeAPI free software, producing results that need to be evaluated and validated by scientific expertise, which requires appropriate visualisation and analysis tooling.

The Container ecosystem spans from spawning a process into an isolated and constrained region of the kernel at bottom layer, building and distributing images just above to discussions on how to schedule a fleet of containers around the world at the very top. While the top layers get all the attention and buzz, this session will base-line the audiences' understanding of how to execute containers.

The talk will briefly recap the history of containers and containers in HPC and describe the challenges we faced and how the community overcame them; eventually converging towards a sustainable model to run HPC application at scale using containers. By attending this sessions viewers will come to understand that HPC runtime engines are not far apart anymore and what to look out for when adopting HPC containers in 2021. We'll also poke at the next layer up - Image build and distribution - to describe the challenge after we picked the runtime engine.

Automate your infrastructure with the same CI/CD tooling that your applications go through

If Continuous Integration/Continuous Delivery is critical for application deployment, why is it not being equally leveraged to manage infrastructure. Most teams I've seen have reached the first goal of defining their infrastructure configuration as code (often with Terraform), but they tend to stop there. Access and/or education on how to run Terraform is given to a few select people, and they then run it in the wild jungle that is there own machine.

In this talk, Jeff with highlight some of the techniques, tools, quick wins, advanced features, and key measurements for putting your Terraform code through the pipes of automation.

With MariaDB in a general case (backup, proper shutdown, storage engines incompatibilities, Galera, async replication, and maybe few bugs and corner cases aside) it should be possible to easily and directly upgrade from one major version to the other, skipping any number of intermediate major versions in between. mysql_upgrade utility is designed to fix all incompatibilities in the mysql.* system tables. In frames of this talk the details of its implementation and actions are discussed, as well as some known bugs and problems that it does not solve. Upgrades to MariaDB 10.4 and 10.5 are covered, from versions at least as old as MySQL 5.5.

In this presentation we will introduce Veracruz, a project recently adopted by the Confidential Compute Consortium, exploring how efficient, collaborative computations between mutually distrusting parties can be developed using a mixture of hardware- and software strong isolation mechanisms. Veracruz uses Arm TrustZone, Intel SGX, AWS Nitro Enclaves, or the high-assurance seL4 microvisor, to provide a "neutral ground" within which a collaborative computation takes place, shielded from prying or interference by the host of the computation. The computation itself is realised by a WebAssembly program which sandboxes the computation, means Veracruz programs are portable across different isolation technologies, and allows multi-party computations to be quickly written in high-level programming languages with standard development tools. Potential use-cases for Veracruz include support for privacy-preserving collaborative machine-learning, privacy-preserving surveys, polls, elections, or auctions, and safely delegating computations from weak devices to more powerful devices, amongst many others.

Veracruz began life as a research project within the Security group at Arm Research. However, after reaching maturity, we recently open-sourced the project on Github (see: https://github.com/veracruz-project/veracruz) as a precursor to adoption by the Confidential Compute Consortium, and all development is now done in the open. We are especially interested in attracting collaborators, as we have many ideas for where the project can go next, and are interested in hearing of other ideas and potential use-cases, too.

Time to look on the past year, and asses where is the Project. This talk will summerize the 2020 reports, give an overview on Discussions and Activities within the Project. If you want a quick look where the Project is and where we head, then Visit this Talk!

Fluence is an open application platform where apps can build on each other, share data and users. Fluence not only allows hosting services inside p2p network but also provides JS SDK for building web applications, which communicate with the services. After the introductory talk, we will dive right into something very practical. We will demonstrate the process of making a web application with Fluence JS SDK. We will start with an empty create-react-app project and work our way towards the fully functional solution. By the end of this talk, we will develop a text editor, which synchronizes it’s state and the user online status with collaborators over Fluence p2p network. The application will be interacting with two minimalistic services pre-deployed to Fluence: user-list and history, but all of the features will be implemented on client-side without any need to modify existing software. Expect a lot frontend and a lot of code in TypeScript!

Foojay is all about the community helping to take Java forward, so as an attendee of the Friends of OpenJDK FOSDEM devroom you are already on your way towards making the Java community better!

But what can we all encourage our friends and colleagues to do in order to make the Java community more vibrant, active, and welcoming.

In this presentation, you will learn all of the insider secrets on how to support the worldwide community of 12 million Java developers.

KubeVirt's architecture is composed of two main components: virt-handler, a trusted DaemonSet, running in each node, which operates as the virtualization agent, and virt-launcher, an untrusted Kubernetes pod encapsulating a single libvirt + qemu process.

To reduce the attack surface of the overall solution, the untrusted virt-launcher component should run with as little linux capabilities as possible.

The goal of this talk is to explain the journey to get there, and the steps taken to drop CAP NET ADMIN, and CAP NET RAW from the untrusted component.

This talk will encompass changes in KubeVirt and Libvirt, and requires some general prior information about networking (dhcp / L2 networking).

You've just had an idea for a great application but don't think anyone else is interested? You've used your weekends and free time to come up with something that actually solves someone else's problem? You'd love to open source your project so others can use it but you don't know where to start. We'll explain the way from an idea to an open source project using a step by step guide - including links, code snippets, and open source tools you can use to open source your own project.

We are using our experience from working at open source companies like Red Hat and Percona as well as our project experience to highlight the steps you can take to get your open source project off the ground. In the Q&A section you can ask specific questions about your project or your idea and we'll give you some tips and tricks that we've used ourselves.

Last year, the world changed, and musicians were among those that were hit the most, and music lovers with them. Can WebRTC help, here? This presentation will try to cover different areas where it could, and in some cases already is.

WebRTC is well known and widely deployed as a communication technology. Most of the times, though, we hear about it in the context of those same boring and traditional use cases that we've all seen thousands of times: conferencing, e-learning, contact centers, webinars, etc. As a very amateur and hobbyist musician, I've always wondered whether WebRTC could do more to support the arts instead: the answer is obviously a strong yes, and I've always been pleasantly surprised when I've seen it used to that effect.

Music is indeed one of the areas where WebRTC could do so much more. Since the pandemic started, musicians all over the world were affected in different ways: no more concerts, or meeting the fans, or jam session, and so on and so forth, basically making it much harder for them to earn a living; the same could be said for those who simply love to listen to music, attend concerts and engage with musicians. What can WebRTC do to help, here, and what are the technical challenges that may need to be overcome?

This presentation will try to cover a few different use cases, ranging from plain streaming/broadcasting (and how WebRTC audio could be improved), tinkering with remote music equipment, playing with friends online and so on. I'll also share some of the experiments I've carried on myself just for fun in this area, the challenges I've identified, and what I'd like to work on next, possibly using the Janus WebRTC Server as a support.

With the NESi software we aim at simulating certain points of a network.

At the Moment we are able to simulate DSLAMs (Digital Subscriber Line Multiplexer) of various vendors including Alcatel, Huawei and KeyMile to name the most popular.

The software itself can simulate the vendors OS running on the network-device and allows the user to configure the amount of network cards, the number of ports on said cards and connected CPEs (Customer Premises Equipment). In the OS itself the user is able to change certain values to configure the device. The traffic on ports can be limited and ports can be dis-/ enabled completely allowing the user to simulate a DSLAM. NESi also comes with a handy GUI which allows easier configuration of network-devices.

The idea of the software originated from Ilya Etingof, the creator of snmpsim. A python based software to simulate snmp calls to a network-device. In a future release of NESi we are planning on integrating snmpsim into our framework as well.

In this talk, the founder of ntop Luca Deri introduces the main ongoing activities of ntop, and its future directions.

This talk will focus on our experiences with making open source tools for the study of social media platforms (amongst others, DMI-TCAT for Twitter, the YouTube Data Tools, and 4CAT for forum-like platforms such as Reddit and 4chan) in the context of social science and humanities research. We will discuss questions of reliability and reproducibility, but also how tools are taking part in shaping which questions are being asked and how research is done in practice - making open source particularly relevant as a form of methodological transparency. Two aspects have become particularly important for our tool-making practice: the relationship with large platform companies and their Web-APIs as well as concerns about user privacy and legal compliance with regulations such as the GDPR. Our talk will address these in turn, scoping the issue and proposing ways forward.

This talk will present a proper procedure of migrating applications from proprietary database systems (such as Oracle or SQL Server) to MariaDB. The talk will give an overview of the steps required to successfully perform a full migration. built from the experience of migrating DBS Bank's core infrastructure from Oracle to MariaDB.

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

This talk will discuss the design, implementation, features, lessons learned, and the current status of the project. The talk will highlight some of the technical challenges of enabling unmodified applications in restricted secure environments such as Intel SGX enclaves.

In order to connect to external databases, PostgreSQL supports Foreign Data Wrappers (FDW), and there are already many FDWs. However, among of FDWs have various restrictions preventing utilization of external databases features. As such a restriction, FDWs for schemaless databases need to change the foreign table definition, when some columns are added in remote database. This restriction can not take full advantage of the schemaless feature. In this time, we considered implementing FDW that does not require changing the external table when columns are added on external database. I would like to introduce this study based on the time-series database InfluxDB as schemaless database.

The PlayStation 2, being the best-selling game console of all time, is a surprisingly complex beast. So, isn't it only fitting that its emulation in software is equally complicated?

With PCSX2 developer GovanifY, we carefully peel back the layers of the world's most popular game console, and its most popular emulator. See why, twenty years later, it's now easier than ever to ＰＬ△︎Ｙ　ＩＮ　Ｙ◯︎ＵＲ　Ｗ╳︎ＲＬ□.

Emotion Engine. Graphics Synthesizer. Built-in DVD player. DualShock. Broadband. Online. $299. Twelve years in production, nearly 4,000 titles, and over 150 million units sold worldwide. The PlayStation 2 is widely heralded as the most popular video game system of all time.

Its unassuming, yet imposing black chassis hides a masterclass in system design. Sony's second-most popular product next to the Walkman, and unquestionably their most successful game console, the PS2 isn't without its faults - chief among them, its complexity. While a vast effort was made on the part of Sony's engineers, ironing out as many quirks as possible to ensure game development was smooth, even seemingly unsophisticated games had required specialized development steps to ensure satisfactory performance, unless they wanted their game to be mocked in the cutthroat sixth-generation-gamer media for having "last-gen" graphics. Why was it so difficult? After all, the CPU is a simple RISC, with a simplified FPU. The GPU, the fabled "Graphics Synthesizer", only draws scenes - no shaders.

PCSX2, the PS2's de facto open-source emulation project, now has the greatest share of tested playable games and working software titles for its console, out of any emulator targeting consoles since then. Unfortunately for us, this compatibility came at the cost of complexity. The long-driven community effort to incrementally improve on it, brought with it legacy code with long, spindly strands which dig deep into the core codebase. Its C-centric codebase, while speedy, was hand-tuned to gain the maximum performance out of contemporary 32-bit Pentium 4 CPUs. The GUI, designed using wxWidgets, aimed for a mythological "middle-ground" of such modern platforms as X11R6, Windows XP, and Mac OS X Aqua.

The project really was a product of its time; emulator development was highly fragmented among incompatible and proprietary video and sound APIs, and to compromise, a plugin interface haphazardly bolted on components, leading to needless headaches over trivial things like joystick input. These remnants of the past have kept coming to haunt us, and we've decided to put our foot down.

Twenty years after the inaugural CVS push, it has come high time to reorganize and transform the shambling heap of code, and with the modernization of such a large project comes many discoveries - not only about the emulator software, but also its target machine.

Points we'll touch on include: The PS2, and its architecture - and the cursed idiosyncrasies that developers and emulator authors have had to battle. Reverse engineering the PS2, and studying its behavior - following a game through, from the DVD, into the I/O subsystem, across the bus, through the cache and memory, across the vector units, and out to the TV. How PCSX2 works - how it is programmed and evolved to take advantage of modern hardware (and why that's a constantly moving target). Finally, we'll conclude with a deep dive into the new x86_64 JIT compilers coming to PCSX2, its clean core/GUI separation being made with portability in mind, notes about refactoring and scope management of a software system at-large with an active user base; new GUI targets, some infrastructure rework, and more!

This talk will do a deep dive on how Ansible can be used to assess the operational state of your IT infrastructure (especially network appliances) and effectively take remediation actions as required

This talk will do a deep dive on how Ansible can be used to assess the operational state of your IT infrastructure (especially network appliances) and effectively take remediation actions as required. The following will be demonstrated for both Linux as well as network devices. Collect the current operational state from the remote host and convert it into normalised structure data. Define the desired state criteria in a standard’s based format Validate the current state data against the pre-defined criteria to identify if there is any deviation. Take corrective remediation action as required. Data validation

Eleventy isn't the first Static Site Generator in Node.js out there. But it gets amazing feedback from different parties. Time to look into what makes it so compelling! We'll touch Setup, Data Directory Files and Template Languages. You'll see, that you have plenty of options to choose from.

Eleventy gained the hearts of the community by storm. But what makes it compelling?

This talk will give you a round about the origin, the people behind it, show you what you can build and how you can help.

You can pick from Liquid, Nunjucks, Haml, Pug, EJS, Handlebars or Mustache or go with plain JavaScript template strings. Data Directories allow for abstracting away recurring frontmatter elements. They can even be leveraged to build entire pages from! Also, you can query an API endpoint and provide the results as Data to your templates.

The build and deploy process can happen whereever you like.

Over the years, there has been extensive efforts to improve Apache Spark SQL performance. This talk will introduce the new Adaptive Query Execution (AQE) framework and how it can automatically improve user query performance. AQE leverages query runtime statistics to dynamically guide Spark's execution as queries run along. The talk will go over the main features in AQE and provide examples on how it can improve on the previous static query plans. Finally, we'll present the significant improvements we have seen on the TPC-DS benchmark with AQE.

Examples of the new runtime optimizations include selecting the right join type (broadcast-hash-join vs. sort-merge-join), dealing with data skew, and automatically selecting the number of shuffle (reducer) partitions.

The presentation describes efforts of porting OpenPOWER architecture firmware to open source firmware framework - coreboot. Although OpenPOWER firmware has been open-sourced some time ago, it may still benefit by implementing the support in coreboot. The differences and benefits of the OpenPOWER firmware and coreboot will be mentioned as well as current progress of work and challenges faced during development.

The IBM POWERPC architecture exists since early 90. Many may also know that the POWER processors were used in Apple Macintosh between 1994-2006. Today the IBM goes forward with their POWER processors releasing newer and newer processor families like POWER9 and even POWER10 recently. Modern POWER architecture features very high computing performance with multi-core processors which makes them ideal for servers and computing clusters. They also are great as a workstation, for example Raptor Computing Systems Talos II (POWER9), which is the reference platform used during the coreboot port. A huge advantage of OpenPOWER architecture is its openness. Compared to modern x86 architecture which is full of binary blobs, POWER can easily rival with x86 domination and dethrone it from the most common used processors architecture in modern computers. Although the OpenPOWER firmware and documentation is open-source the development of coreboot for POWER9 is very challenging and full of unknowns. In this presentation you will hear about the current progress of the work on coreboot POWER9 support, what problems we face and how much effort it takes to enable new architecture in coreboot.

There are a number of available tools and approaches for benchmarking S3 performance in Ceph. Benchmarking reliably and sensibly gets more challenging as you scale out storage clusters, gateways, and benchmarking drivers. In this talk I’ll go over some of the benchmarking tools we’ve used in recent months, talk about our focus around COSBench, and some of the approaches and steps we took to improve the state of COSBench for Ceph benchmarking, both in COSBench itself and with helper tools.

The guarantees provided by SPARK, an open-source formal proof tool for Ada, and its analysis are only as strong as the properties that were initially specified. In particular, use of third-party libraries or the Ada standard libraries may weaken the analysis, if the relevant properties of the library API are not specified. We progressively added contracts to some of the GCC GNAT Ada standard libraries to enable users to prove additional properties when using them, thus increasing the safety of their programs. In this talk, I will present the different levels of insurance those contracts can provide, from preventing some run-time errors to occur, to describing entirely their action.

Aquamarine is the multi-process composition medium based on pi-calculus, designed for distributed applications/backends, both in private deployments and open networks. Aquamarine scripts define the topology of the execution (when and where to move control flow) and data dependency graph (what results and what arguments to pass where), essentially describing the composition of (micro)services, e.g. using one service's output as another service's input. The language primitives are based on pi-calculus operations describing certain topological effects and secured by cryptographic signatures of involved peers. The Aquamarine approach allows building distributed systems of any complexity, effectively expressing network behavior.

Introduction to the Linux Test Project Fuzzy Sync C library, developed for reproducing data races in the Kernel from user land. Will cover a simple contrived data race, entirely in user land, to demonstrate the basics. Then we will move onto real world examples within the kernel, including when a delay bias is required to ensure a particular chronological order of events.

Fuzzy Sync was developed for reproducing Linux kernel bugs, however it may be used to collide events in user land, another kernel or other contexts. No particular kernel features or instrumentation are required. The Linux Test Project is a large test suite for the Linux kernel and POSIX. Most of the tests are stand alone executables which run in user land and interact with some low level kernel interface. Fuzzy Sync is primarily used in regression tests which attempt to reproduce a particular bug. This ensures the bug is not reintroduced and indicates if a patch needs back porting to older kernels.

The seL4 Foundation was created in April 2020 as a Project of the Linux Foundation. Its aim is to provide an open and neutral framework for developing seL4 and its ecosystem and promote update. The talk will give an overview of the seL4 Foundation, its goals and activities and the benefits of joining.

The World Wide Web’s original design as a vast open documentary space built around the concept of hypertext made it a fantastic research field to study networks of actors of a specific field or controversy and analyse their connectivity. Navicrawler, IssueCrawler, Hyphe... Over the past 15 years, a variety of web crawling tools, most often free and open source, have been developped by or for social sciences research labs across the world. They provide means to engage with the web as a research field or to teach students what the WWW is beyond Google or Facebook’s interfaces.

We will first present an overview of this history of open source web crawling tools built for research, teaching or data journalism purposes. Then we will propose a short demonstration of the latest version of médialab's HyBro, aka Hyphe-Browser, a tool built to let users benefit from automated web crawling as well as in situ web browsing and categorizing. Its friendly user interface allows a variety of publics to engage with web crawling, including non-experts like students, social science scholars, and activists.

Exploring viable methods to build decentralized, secure, encrypted p2p tracing/logging/capture swarms using HEP and DHT to provide for the present and future needs of webRTC platforms and other next-generation real-time communication systems.

I plan to bring modern OO to the Perl core. Modern enough that it leapfrogs the capabilities of the OO systems of many other dynamic languages. I’ve been stealing ideas from Stevan Little, Damian Conway, and anyone else foolish enough to leave their ideas lying around. I have no pride. Sawyer’s expressed interest and it's likely it will go into the Perl core, though with the upcoming Perl governance changes, the timeline is unclear.

I’m not going to beat around the bush: writing object-oriented code in Perl is a shambolic mess. Some people want to use bless and hand-roll everything, others insist upon using Moo/se, while still others others reach for Class::Std, Spiffy, Class::Tiny, some in-house monstrosity their company uses and so on. You have to relearn it again and again and again. It's time to put this embarrassment aside.

The Apache OpenOffice wiki is the major source of information about OpenOffice for developers. A major restructuring is ongoing an d we will discuss what has been done and what remains to be done.

Introduce a use case from a Chinese who migrated one of their important applications from Oracle to MariaDB with very few modifications to the application. I will cover the entire migration process and experience, including tools to check the Oracle syntax compatibility with MariaDB and tools to compare the execution results of Oracle and MariaDB, and the proxy that receives and interprets the Oracle network protocol to MariaDB

Existing attestation schemes require pre-signed enclave images and provide few means of including runtime-dependent configuration data (like report data, enclave held data, configid). In multi-party settings in which the parties may not always fully trust each other, attestation of multiple pieces of code or data images via these means is cumbersome and inefficient. For example, consider the case of a secure cloud service running a JavaScript interpreter, which interprets a third-party script, in which case both, the interpreter and the script, can interfere with each other's attestation evidence as they share an address space. Similarly, a group of users may want to compute a shared result over all of their combined data, but without sharing their data with each other. Attestation in such scenarios is greatly simplified by a technique called Extended Enclave Initialization Data (EEID), which provides a secure and convenient means to combine all required attestation evidence, and to automatically re-sign images (with a well known service key) during enclave startup to ensure that all of the code and data is loaded and attested appropriately. An added benefit is that even single-party applications can use this technique to automatically re-sign enclave images with modified configuration settings (like memory size and thread count), independent of, or in addition to, underlying TEE support for configuration changes. EEID is currently available as an experimental feature for SGX enclaves in the Open Enclave SDK and it is used in multiple prototype services at Microsoft.

In this presentation we showcase how ntopng could be straightforwardly transformed to an indispensable trust-enhancing tool with many attractive features, i.e. simplicity, affordability and open-ness. We will finally share some first views from its deployment in a connected home testbed environment.

The connected home enables the interconnection and interoperability of various types of end-points catering for applications like connectivity/networking, media/entertainment, physical security, energy monitoring, or even healthcare, fitness, wellness, and more recently, given the unprecedented challenges of the COVID-19 outbreak, remote working. From advanced control of previously non-connected devices such as home appliances, to the employment of smart IoT platforms, the connected home end-user enjoys an extraordinary degree of convenience and money-saving capabilities. However, this level of automation comes at a price: every single connected device may act as a potential trojan horse, a backdoor compromising the privacy, the cyber security and even the physical safety of the house. We argue that as more and more connected things are incorporated in our digital environment, there is a need to develop new robust, open, and easy to use tools to help users increase trust and achieve greater control over their devices fleet. In this presentation we will introduce the EU Project TOTEM, jointly carried out by ntop and FERON TECHNOLOGIES. The project is an attempt to increase the trust in connected homes through the provision of improved information to end users about their home network security status, on a simple, usable, and comprehensible way.

Most software developers are not also data scientists or machine learning experts.

They don't know machine learning workflows, math, data analysis and model building practice, and tricks.

Mastering these skills can take months or even years.

Learn about the shortcut that can quickly turn a software developer into a deep learning developer: an IDE that guides you in building advanced machine learning models and deploying them into your applications.

Many open-source libraries provide an interface for the Twitter API. However, most people use these tools in temporary scripts for a one-time tweets collection. Moving to a robust application for collecting and indexing tweets over long periods of time requires some programming knowledge that most social science researchers do not master. In order to meet this need, the medialab has developed gazouilloire, a tool that makes it possible to easily configure the collection parameters (keywords searched, language of tweets, location of tweets, etc.) and can then be launched from the command line.

Gazouilloire combines two methods to collect tweets from the Twitter API ("search" and "filter") in order to maximize the number of collected tweets, and automatically fills the gaps in the collection in case of connexion errors or reboots. It also provides a large range of features that are not directly available from the free Twitter API: collecting during specific periods of time, resolving redirected urls, downloading only certain types of media contents (only photos and no videos, for example) or unfolding Twitter conversations. The user can then choose to export the tweets in csv format, and select the fields that will form the columns of the table.

Social science researchers have already used gazouilloire for a wide variety of studies: measuring online activity during COVID-19 lockdown, studying the public discourse of anti-vaxxers, or monitoring urban nature policies, among many others...

Performing schema changes on a live system is challenging because it often involves high level of locks leading to downtime. It becomes harder and harder when the number of databases to manage raise continuously. At OVHcloud, a major cloud computing provider in Europe, we used to manage such changes approximately. With our startup mindset, we used to yell "Who can ALTER my database?" and hope for someone sitting next to you to answer. Database engineers were used to copy paste bunch of SQL statements on production databases directly. What happens if a bad character is inserted? What if there is no transaction in the script? What if you run the migration on the wrong database? It works, sometimes. Lots of tasks are boring. This one was on top of our list. In this talk, you will discover our feedback on how we have reduced efforts, time and human errors by automating databases schema migrations using git, code reviews, CI/CD, migration tools, service discovery and automation systems at the OVHcloud scale.

VM sockets (vsock) enable communication between hosts and VMs. The vsock use cases have grown over the recent years to also cover cloud and containers projects. Andra and Stefano will walk through the details of a set of projects focused on isolation that use vsock as a communication channel. Then they will present debugging tools and further work items for improving and adding new features for vsock.

In the last years, many projects have been developed to increase security and isolation in the cloud and containers, such as Kata Containers, Nitro Enclaves, and libkrun. All these projects leverage Linux KVM (Kernel-based virtual machines) to create a more isolated environment. They use VM sockets (vsock) to provide a communication channel between constrained and less constrained worlds, reducing the attack surface.

These VM sockets are provided by the AF_VSOCK address family and the virtio-vsock device. They offer a very simple configuration and the possibility to use POSIX sockets to communicate between hosts and VMs.

Andra and Stefano will give a brief introduction of AF_VSOCK and virtio-vsock. Then they will illustrate how the projects and features, mentioned at the beginning, use VM sockets. They will present a couple of demos to explain how to use several tools for easier debugging and performance evaluation of vsock.

At the end, they will share an overview of a set of new features such as namespaces, multiqueue, and shared memory. These are planned as future work to further grow the ecosystem for virtio-vsock.

This talk introduces DiscoPoP, a tool which identifies parallelization opportunities in sequential programs and suggests programmers how to parallelize them using OpenMP. The tool first identifies computational units which, in our terminology, are the atoms of parallelization. Then, it profiles memory accesses inside the source code to detect data dependencies. Mapping dependencies to CUs, we create a data structure which we call the program execution tree (PET). Further, DiscoPoP inspects the pet of a program to find parallel design patterns and parallelization suggestions in terms of OpenMP constructs and clauses. By far, DiscoPoP detects doall, reduction, pipeline, task parallelism, and geometric decomposition in a program.

We used DiscoPoP to create OpenMP versions of 49 sequential benchmarks and compared them with the code produced by three state-of-the-art parallelization tools: Our codes are faster in most cases with average speedups relative to any of the three ranging from 1.8 to 2.7. Moreover, we analyzed the LULESH program and an astrophysics simulation code with DiscoPoP. In LULESH, we identify most of the parallelization opportunities which have been parallelized by expert programmers manually. In the astrophysics code, DiscoPoP finds unexploited parallelism opportunities and achieves a speed-up of up to 35%.

DiscoPoP is released as an open source software and can be downloaded from:

https://github.com/discopop-project/discopop

Matrix (https://matrix.org) is an open protocol for secure, decentralised communication - defining an end-to-end-encrypted real-time communication layer for the open Web suitable for instant messaging, VoIP, microblogging, forums and more. We introduced P2P Matrix at FOSDEM 2020, and throughout 2020 we've been working on improving P2P Matrix. This includes massively improving Dendrite, our next-generation Matrix homeserver implementation, implementing P2P Element for genuine mesh networks on iOS via AWDL, using Yggdrasil as a P2P overlay network - and more recently implementing Pinecone; a next-generation P2P overlay network inspired by Yggdrasil which supports source routing and virtual ring routing as well as typical greedy routing. In this talk we'll show off all the progress and give a VIP tour of Pinecone.

Matrix has traditionally been a decentralised rather than distributed protocol - with conversations replicated over all the servers whose users are participating in that conversation. However, Matrix clients connect to only one homeserver, which then becomes a central point of control over that account, even though the conversations themselves are decentralised. P2P Matrix changes everything by making the protocol completely distributed; compiling down the whole server stack to run within the client, and connecting the clients together over a P2P overlay network such as libp2p, Yggdrasil or our new Pinecone overlay. The approach is particularly nice because the client code doesn't need to change at all: it just connects to a local server rather than a remote one.

We'll demonstrate the work we've done on our Golang Matrix server implementation, Dendrite, in order to get it robust enough for P2P (which is a great stress test!), explain Pinecone, and give the latest updates on decentralised accounts, privacy preserving relay nodes, and how we'll turn Matrix into a hybrid P2P/client-server network in the future!

“We are all YAML engineers now” as Bob Walker said in 2018 in Ghent. So we now need something to manage these millions of lines of YAML. There’s the “Kubernetes application management tools” list by Bryan Grant with over 120 tool aiming at config management for Kubernetes. This area is evolving fast, and as k8s users we need some guidance to make informed decisions on what to use. In this talk I’ll describe the problem I need to solve and take a look into what we can learn from the previous generation of cfg mgmt tools. Then, will show some of the new tools and methods. Will not go into details of each solution, but rather compare different approaches and discuss which is good for specific needs.

We are convinced that young people can make an important contribution to the Free Software community. They see many things from a different perspective than adults, which is worth looking at more closely, because new ideas and points of view can be integrated into the development of free software. Since most children and young people are already in contact with the digital world at school, we want to involve young people in the development of software. In our presentation, we will show how we include the youth into the free software community with the schul-frei project. It shows educational establishments the advantages of free software and presents solutions they could use. The goals of the project are not to offer only software. It allows for example students and teachers to develop apps together for their school, which can be integrated into the running system we present.

Teckids e.V. is a German association which provides a legal frame for three technological projects. We manage the project called "schul-frei", which aims to bring digitisation with free software to schools. We especially value the participation of youth in these projects, because they are the people which are affected by digitisation the most. Our educational concept is also based around the idea that young people should be judged by their abilities, not by age. They should learn to take responsibility and be independent. An example of this would be the AlekSIS project. It is (mostly) developed by adolescents from Teckids e.V. and from the school Katharineum zu Luebeck, where it is actively used. AlekSIS is a web-based school information system which can be used to manage and/or publish organisational subjects of educational institutions. It is also part of the schul-frei canon and uses the EUPL. We also present and provide support for solutions such as Moodle or BigBlueButton for E-Learning and debianedu/skolelinux with Nextcloud for school networks on our website https://schul-frei.org/en/index.html We set up comprehensive platforms for schools, education and youth institutions in time for the increased demand for online teaching. This has contributed to the fact that more education providers are interested in these solutions and that the various projects are gaining in reach

The LibreSOC Project is a hybrid 3D CPU, GPU and VPU, designed for use in mass-volume products such as smartphones netbooks tablets and Industrial SBC IoT. As such, user trust and reduced product development costs are both equally important. Both these goal are achieved by providing full source right to the bedrock (Hardware HDL, bootloader, drivers, everything) and deploying strict transparent "Libre" development criteria. The project has EUR 350,000 funding from NLnet under their PET Programme and is actively seeking developers.

Analysis of SoCs (system-on-a-chip) used for embedded, mobile and IoT shows a decade-long disturbing persistent trend that is almost 100% without exception across hundreds of integrated processors: not a single recent SoC with modern performance in the past 10 years can be used 100% effectively without at least one closed source driver. The choices for developers and end-users alike is very stark: go without the GPU, or without the VPU, or without some key critical functionality that would penalise performance or business effectiveness entirely, or compromise on integrity and end-user trust, and reduce product reliability by delivering closed source binary-only drivers.

Even the highly-regarded Freescale/NXP iMX.6 which uses Etnaviv for the GPU, and has a 19-year Long-Term Supply committment, is still burdened by closed source 3rd party binary-only drivers for the VPU. Huge multi-man-year efforts consuming precious FOSS engineer resources that could be productively deployed elsewhere are wasted on reverse-engineering these closed SoCs.

The kicker: unlike a Desktop system where swapping out the Graphics Card is a 15 minute job, you cannot replace the VPU or GPU or crypto-block on an integrated System-on-a-Chip, and you certainly cannot disable the boot-level DRM that prevents booting anything other than pre-approved signed versions of u-boot (Otherwise fantastic Windows 10 ARM laptop products using the Tegra processor quickly became landfill due to the BIOS-level DRM locking that chained right through to applications. applications that could only be downloaded once a Microsoft online account had been registered)

This situation is one that is not deliberate: it's a product of how SoCs are put together. It is simply easier for Fabless Semi Companies to license off-the-shelf solutions (GPU hard macro, VPU hard macro) with their associated closed source secretive drivers than it is to tackle what is effectively, to their perspective, a hindrance to sales and profits: issues faced by end-users who know nothing about source code or the close relationship that source code has to "Right to Repair" and security vulnerabilities.

Unbelievably, then, after more than 10 years of waiting for even just one SoC manufacturer to come out with an SoC that has full source code for its GPU, VPU, bootloader and all other integrated HDL, the solution is to design and bring to market an SoC that does exactly that, developing integrated 3D GPU and VPU capability into the same and providing a 100% committment to provide full source, right to the bedrock: HDL, bootloader, drivers, OS: everything.

This huge project requires concerted community effort and coordination with many stakeholders. Significant care is taken to appraise the OpenPOWER Foundation of the ongoing efforts and enhancements being developed on top of OpenPOWER, with a view to proposing the 3D and Video instruction enhancements to the OpenPOWER Foundation for review.

Accessible code editing with CodeMirror 6

Thola is a new open source tool for reading, monitoring and provisioning (coming soon) network devices written in Go. This talk will inform about the current state of development as well as planned features, including reading out inventory, configuring network devices, support for other monitoring systems like prometheus and many more.

It serves as a unified interface for communication with network devices and features a check mode which complies with the monitoring plugins development guidelines and is therefore compatible with Nagios, Icinga, Zabbix, Checkmk, etc.

Thola features:

• reading, monitoring and configuring (coming soon) network devices from Cisco, Juniper, Nokia/ISAM, Brocade, Huawei and many more

• support for different network device types like switches, routers, WDM, directional radio, UPS, DSLAM/OLT,... including type specific requests and checks

• an easy way for adding support for additional devices by YAML configuration files

• support for different network protocols like SNMP, HTTP(S), telnet/ssh (coming soon) and more

• a check plugin mode compatible with Icinga, Nagios, Zabbix, Checkmk, ...

• a REST API mode

• low resource needs

For more informations, feel free to have a look at our GitHub!

Two years ago I showed how to use XWiki as a development platform to build collaborative content centric applications while last year I did a short demo about how to use XWiki to setup a collaborative intranet in just 20 minutes. This year I propose a demo about how to create a public website with XWiki, and use XWiki like a content management system (but a collaborative one). The appeal of XWiki for such a usage is the possibility to integrate all usages in a single tool (intranet - see last year's talk - or any other content centric collaborative platform - see the talk from 2 years ago), while not completely missing the presentation features of "classical" content management systems.

PANDORÆ : Retrieving, curating and exploring enhanced corpi through time and space Mapping the state of research in a particular field has been made easier through commercial services providing API-based bibliometric-enhanced corpuses retrieval. Common assertions such as “the use of CRISPR technologies has skyrocketed in laboratories all around the world since 2012” can now be easily verified in both quantitative and qualitative perspectives using those platforms. Such services as Elsevier’s Scopus propose inbuilt functions to explore corpuses chronologically and geographically. They don’t, however, allow for hand curation and enrichment of the corpus. This lecture advocates for a solution to this methodological issue using PANDORÆ, a free and open source software designed for that purpose. PANDORÆ requests corpuses from the Scopus API, enriches its data by geolocating each document’s affiliations, and then uploads the resulting dataset to a Zotero library. The user is then free to curate the corpus, adding, editing or removing items. PANDORÆ allows downloading it back from Zotero to its internal databases, and to display the enriched corpuses on a map, on a timeline, or as an author-directed force-layout network graph.

This presentation will also introduce more advanced PANDORAE features, such as displaying Twitter dataset obtained through Gazouilloire, mapping web entities loaded from Hyphe and scraping biorXiv results using Artoo.

What's new in Ceph RGW

Ceph is an open source, highly scalable, software defined storage that provides object, file and block interfaces under a unified system. Ceph Object Storage Gateway (RGW) provides a RESTful object storage interface to the Ceph Storage cluster. It provides an interface that is compatible with a large subset of AWS S3 APIs. In this talk we will discuss the upcoming features in ‘Pacific’ release and beyond. The list of features are: S3select Lua scripting Encryption - kmip, kms backend, sse-s3 D3n cache Gc OMAP offload Xattrs in nfs Hadoop connector that uses rgw Bucket notifications: addition of persistent bucket notifications Zypper multisite enhancements

WebRTC means many things to many people. One of these things is the C++ library that is used to implement the WebRTC functionality such as audio, video and data channels in the Chrome browser. The library is a complex beast with more than a million lines of code and a history dating back to 2004. It implements a wide range of network protocols and audio/video codecs. The interaction between WebRTC and Chrome is heavily influencing the how features are developed, reviewed and shipped to millions of users. In order to successfully contribute one has to understand both the tooling as well as the review process and how changes get into Chrome eventually.

I am going to explain that process using two examples: - a trivial logging change - a feature to enable audio redundancy

The logging change, while trivial, is a great example of the mechanics how a change gets uploaded, reviewed and shipped.

Audio redundancy is a complex feature that attempts to solve a very hard problem, audio quality. Getting that feature considered even required data about the efficiency. The implementation turned out to be relatively complex, involving ten different changes in total. While implemented in the WebRTC library, it has not yet been shipped enabled by default in Chrome since evaluating and tuning the implementation at scale in the real world is difficult.

Contributing back to the WebRTC library may be difficult, it is possible and contributions are welcomed. We just need more of them!

Many organizations do not have the resources to supervise their OT/ICS networks, but they heavily rely on them. In this presentation Martin will show what is doable with ntopng to monitor OT/ICS networks. The aim is to get you started with network monitoring. You will see how to baseline your network, define what to detect and how to alert.

Enclave technologies such as SGX generally have a relatively high context-switching cost. This is particularly noticeable when doing (network) I/O. In this talk we'll present the first non-LibOS implementation of an asynchronous I/O model for SGX. This gives you a language-native async I/O programming experience in Rust, outperforming any other way to build SGX network services.

MariaDB has been releasing packages for ARM for quite some time now. ARM is known to have a lower cost of ownership there-by delivering more TPS for the same cost, effectively generating cost savings. Any changes to the working production environment would surely make DBA/dev-ops anxious and we are talking about migrating to a different architecture altogether. How complex is that? Is it feasible? Is it the right time to look into it? What about the ecosystem/other aspects?

We will try to answer all such questions through this talk. We would discuss the why and how aspect, highlighting the step-step approach how user could migration existing MariaDB cluster to ARM, tools compatibility, do and don't, revert back to the old system (if needed rarely), etc....

This is a live panel session which gathers speakers from three lightning talks about web mining tools and technologies.

The push for paperless bureaucracy has been going on for quite some time, but the circumstances of the past year made the issue even more pressing than it already was.

The PDF specification outlines a number of security features, including but not limited to encryption, digital signatures and redaction support. The goal of this talk is to give a broad overview of the various security mechanisms provided by the PDF standard and their applications in the real world, with a particular focus on digital signing.

The push for paperless bureaucracy has been going on for quite some time, but the circumstances of the past year made the issue even more pressing than it already was.

PDF has played---and continues to play---an important role in this digitalisation process. This is in large part due to the format's reputation for robust, platform-independent rendering, but its easy-to-use, natively supported security features are another key selling point. PDF documents can be encrypted using AES or public-key encryption to keep their contents away from prying eyes, and the PDF specification also includes native support for redacting documents before public release. Last but not least, electronic PDF signatures as a replacement for old-school "wet ink" signatures have been a major factor in moving towards paperless workflows for companies and governments alike.

Document security is a complicated and broad subject, with many different facets that often conflict with one another. In particular, developers of workflows handling sensitive documents regularly face tough judgment calls weighing security requirements against ease of use. The security features in the PDF specification provide a standard framework to respond to these needs. In this talk, we'll discuss how you can leverage PDF to build secure, yet user-friendly document workflows. In the context of digital signing, we'll go over what it means to "trust" a digital signature, and how that trust is validated in practice. In addition, the talk wil touch upon some of the common pitfalls in PDF security that you should be aware of to prevent your documents from being exploited.

This talk aims to give a user’s perspective on FLOSS tools for open research in social science. It will be based on personal experience with a team project that aimed to analyze the Twitter follow graph of last year’s FOSDEM and CHAOSScon participants. The project used open source tools and agile management: data was collected with a command line tool (Twarc), network visualization was done with Gephi, and Framagit provided a collaborative framework for managing code, data, visualization and text.

Implementing this project led to insight about what it takes for social scientists who have minimal tech knowledge and culture, to practice open research with FLOSS tools. This talk will specifically address three types of challenges I faced : training, documenting, and collaborating.

This talk will be particularly relevant for people who are designing FLOSS tools in interdisciplinary research environments. More generally, it can be of interest to people who attended the Open Research Tools and Technologies devroom talks in 2020.

Tracing is awesome. Full stop. But what tracing? In fact, even just on Linux, there are quite a few tracing solutions, aren't there they? In this session we'll show off and compare ftrace and LTTng and, for visualizing the collected data, KernelShark and Trace Compass when tracing both baremetal and virtualized systems.

With tracing, we can get to understand what is really happening while our software is running at a great level of detail. Depending on the adopted tracing solution, that applies to user-space components, to OS kernels or even to both. The collected data can be very helpful when investigating bugs and misbehaviors, but can also be used for understanding the internals of the system and for chasing performance degradations or improvements.

On Linux, tracing can be done in a variety of ways. This talk will focus on two: ftrace and LTTng. The aim is describing their characteristics and show how each one works. After that we will show what are the main differences between them in terms of what they are capable of, how the are used and last but not least the overhead they introduce, measured with several benchmarks.

We will also cover the tools that one can use to visualize the often huge amount of data that is usually collected during a tracing session. Both textual ones, such as trace-cmd and babeltrace2, and graphical ones, such as KernelShark and Trace-Compass.

Last but not least, we will offer some insights on how to use these two mechanisms for tracing virtualized environments. I.e., how can you use them for tracing what is going on both on the host and inside one or more guests, at the same time, and how good are they for such purpose?

Microkernels, partial virtual machines and internet of threads are not unrelated. The challenge of this talk is to show that the new libioth providing an effective and flexible support for the internet of threads can open interesting perspectives for a wider range of applications.

A network protocol stack can be implemented as a library. There are several examples: lwip/lwipv6, picoxnet, lkl. These libraries can be used to implement processes connected as network nodes (the so called "Internet of Thread" processes) or to implement network protocol stack servers for microkernels.

The main goal of libioth is to provide a convenient API to interoperate with different network stack implementations. Libioth is also an infrastructure where the actual implementations can be loaded as plug-ins.

Libioth's API is minimal: it includes the complete set of Berkeley Sockets functions, some functions to add or delete a stack and 'msocket', an extended version of 'socket' providing one more leading argument to select which stack should manage the communication.

Libioth does not provide in its API any specific function to set up the network configuration, e.g. to configure the IP addresses/routes etc. These features are provided through netlink (see RFC3549). "nlinline" is a simple and effective set of inline functions to manage the network configuration.

The data link layer infratructure used by libioth is VDE, Virtual Distributed Ethernet.

Although libioth has been primarily designed for the Internet of Threads, the way it is used in the vunetioth module of vuos has many similarities with the network protocol stack servers for the microkernels.

Several concepts and many building blocks of libioth can be useful in microkernel development. The design of the minimal API itself can be used to reuse existing stack implementations in network protocol stack servers. Libnlq (a sibling project of libioth) is a library able to process netlink requests, and can be used to add the netlink support to those stack implementations providing configuration through a custom specific API.

Node.js’ single-threaded nature makes it very susceptible to DOS attacks. While Node.js’ event loop allows performing some operations in an asynchronous fashion, it’s still quite easy to write a vulnerable Node.js application by making a few simple mistakes. In this talk I’ll cover some common ways a Node.js application may be vulnerable to DoS attacks and some common best-practices and counter measures to defend against such attacks.

The TPF is passionate about helping our software communities flourish.

This is an update from a legal and marketing perspective on the communities' brands and some suggested next steps to help them flourish.

The Collabora Online code-base can bring the power of LibreOffice into an iframe inside your web app. Come and hear how we've made that power even prettier and more functional for your user's delectation.

Collabora Online is super-easy to integrate with content management applications, come see some pictures of many successful integrations. Understand how the product works, scales and can bring a very easy to deploy bundle of interoperable document beauty to your application. See the internals of Collabora Online, and checkout how you can get involved with building, debugging, and developing it. Hear about our growing community, and all the changes we've done to make life better for our users, integrators and contributors in the last year.

In this talk I will be talking about base. Base is the Database focused Application within Apache OpenOffice. We will start of with a short Description where Base comes from, and what the Idea behind base has been. I will sum up discussions that have taken place on development Mailinglist. And I would like to take some visions up from the previous discussions and talk a bit about what Base would needs if we would go into the direction of analytics and big data.

Small businesses and non-profits may opt for Platform-as-a-Service solutions such as Heroku to avoid the operational burden of managing their own infrastructure. However, PaaS solutions quickly become cost-prohibitive for compute- or memory-intensive applications. In this talk, I’ll demo an open source infrastructure automation toolchain based on Ansible, Github Actions, Vagrant, Packer, Terraform, and Sentry. Once instrumented, this toolchain incurs a $0 recurring cost and can be safely and trivially scaled up. Each component of the toolchain requires minimal operational expertise and is managed through a UI. State-change notifications are routed to email or a Slack channel, ensuring everyone stays on the same page. Test, deploy, monitor, and scale transparently, and with confidence!

The talk will demonstrate how to make the most of free, open source infrastructure tooling to fully automate tests, monitoring, code deployment and infrastructure deployment. You can get a lot of mileage out of free!

Even though it is 25 years old, Java is still a modern and one of the most used programming languages. For this, the language, the APIs, and the runtime have been dramatically improved over the years.

As a Java developer since the early 1.0 days, the presenter has collected extensive information over the years and has finally put it together on the Java Version Almanac website: https://javaalmanac.io.

In this session, we take a look behind the scenes of the Java Version Almanac and touch on some trivia about the history and future of Java.

Seeing Zoom used for interviews and "virtual audiences" throughout the pandemic was humiliating for those of us who build projects and products with WebRTC. There must be a better way; and there is - building a WebRTC platform to generate feeds that broadcasters and event producers can consume as they see fit - no need to show Zoom's UI on TV any longer! This is the tale of how and why we built the service that's been used to record all of the RTC track sessions at FOSDEM.

In this talk, we present an open-source framework to develop heterogeneous, distributed enclaved applications. The main feature of our framework is to provide a high level of abstraction over the platform-specific TEE layer and over the secure communication between different modules, leaving to a developer only the task to write the application’s logic. We provide a notion of event-driven programming to develop distributed enclave applications in Rust and C for heterogeneous TEEs, including Intel SGX, ARM TrustZone and the open-source Sancus. This heterogeneity brings our work to a broad range of use cases, which include cloud processing, mobile devices and lightweight IoT. Our framework ensures strong security guarantees based upon mutual attestation of security-critical software components.

A Trusted Execution Environment (TEE) is a relatively new technology that allows to run an application in a special hardware-protected environment called enclave. Enclaves are cryptographically isolated and protected from the rest of the world, ensuring strong confidentiality and integrity guarantees. Moreover, a mechanism called Remote Attestation is used to obtain a proof that an application running on a remote server is loaded inside an enclave and was not tampered with at loading time. There are several TEEs available in both industry and research worlds, each of them is platform-specific, come with different system footprint, and provide slightly different security guarantees: open-source developments include Sancus and Keystone; proprietary options are, e.g., SGX for Intel processors, SEV for AMD, TrustZone for ARM, etc. Therefore, developing a heterogeneous, distributed application that uses different TEEs is non-trivial for a developer, who needs to adapt the code of each component (or module) to a specific platform. Open-source projects such as Open Enclave SDK and Google Asylo aim to bridge the development gap between different TEEs. However, software engineers still need to account for the communication between different modules, which has to be properly secured with cryptographic operations for data encryption and authentication. After the development phase, a system operator is responsible for deploying this distributed application on the (potentially shared) infrastructure: each module has to be properly initialized and attested (e.g., using Remote Attestation), and connections have to be established (e.g., by creating and distributing session keys). In summary, ensuring strong confidentiality and integrity guarantees in such a situation is difficult and error-prone.

The framework we are developing automatically handles all of this work: deployment, attestation, configuration, provisioning of communication APIs. Therefore, it provides the developer an abstraction layer in which they only need to implement the application’s logic. The idea behind our implementation is based on the concept of Authentic Execution, which aims to ensure a strong integrity guarantee over the whole execution of an application. The following citation from our previous paper describes the goal of Authentic Execution:

"Roughly speaking, our notion of authentic execution is the following: if the application produces a physical output event (e.g.,turns on an LED), then there must have happened a sequence of physical input events such that that sequence, when processed by the application (as specified in the high-level source code), produces that output event." (from https://people.cs.kuleuven.be/~jantobias.muehlberg/stm17/paper.pdf)

Note that this concept focuses mainly on the integrity of an application: however, confidentiality comes for free in our implementation, thanks to confidential computing provided by the TEEs and authenticated encryption of the data.

Currently, our framework supports Intel SGX, ARM TrustZone and Sancus (an open-source, embedded TEE for lightweight microcontrollers), allowing the development of applications that can be used in a broad range of use cases, which include cloud processing, mobile devices and lightweight IoT. Our purpose is to provide end-to-end security from low-end systems that include I/O devices to high-end computation nodes. In the presentation, we will demonstrate the use of our framework on the example of a prototypic secure smart irrigation system, a typical use-case for Smart Environments. This example combines SGX and Sancus together to build a secure, heterogeneous system composed of data processing servers and low-power microcontrollers.

Our work also focuses on code quality, especially in order to ensure absence of memory-corruption vulnerabilities. This is essential for enforcing the security guarantees we are aiming for: TEEs and crypto are not helpful if the code is bugged. Hence, the SGX part of our framework was entirely written in Rust, a modern and fast programming language that provides by nature protection against all low-level memory-corruption vulnerabilities. Work for ARM TrustZone is currently ongoing. We are exploring the use of Rust and C in this implementation as well. Sancus is based on the embedded MSP430 processor with a 16-bit CPU, and therefore its implementation was written in C and assembly. Testing and verification techniques are to be applied here to ensure the absence of memory-corruption vulnerabilities.

Our framework aims to minimize the developer’s effort as much as possible: only the application’s logic should be implemented by them, leaving all the details about enclaved execution, secure inter-module communication and Remote Attestation to our framework. To ensure this, the system operator writes a configuration file called deployment descriptor, which includes information about the nodes where the modules will be deployed to, as well as the declaration of connections between two different modules. We implemented a tool that takes as input the source code of all the modules and the deployment descriptor, and it automatically deploys the distributed application according to the information provided in the descriptor. In addition, Remote Attestation is automatically performed to verify the correctness of each module and to exchange session keys for the inter-module communications. Work is in progress to provide complete abstraction over the underlying platform where a module is executed: the ultimate goal is to write an application’s module without having prior knowledge about whether it will be executed on e.g. a SGX or a TrustZone platform. However this is a non-trivial challenge, since two platforms might present huge differences (e.g., Sancus and SGX), and since many features are only available on specific implementations (e.g., Secure I/O).

Mariabackup is another backup tool for MariaDB. But it is still not used very frequently. In this presentation we will have a short look how this backup works and what we can do with it.

Mariabackup full backup is a fast and reliable backup/restore method for a whole instance. With the partial restore we can also restore one table or several tables together (aka schema). Point-in-Time-Recovery is also possible with Mariabackup (do not confuse this with incremental backup). But it becomes more tricky for one schema or table only. And finally this can also be done on a MariaDB Galera Cluster.

The game has changed, FOSS OS and software is everywhere running on every CPU architectures and devices. Even mass consumer computer manufactures are producing with "new" CPU architectures. In 2020 thanks to the Open Power ISA have opened Power Architecture new Chips. It's the right time to have (back) Power Architecture for Open Source Hardware lovers, in educations, makers, hobbyists, consumers and gaming electronics. We will see concretes present projects and future options.

This year IBM released the A2I,A20 POWER processor cores design (softcore) licensed with Creative Common CC-BY 4.0 and associated FPGA environment. In 2019 IBM opened the POWER Instruction Set Architecture (ISA) so now others chip manufactures could produce Power Architecture royalty-free chips . We discover how the FOSS have permitted to manufacturers to adopt newer CPU Architectures and how will be redesigned electronic adopting Open Source Hardware for motherboard and CPU design. We will focus on Open Hardware concretes projects around Power Architecture like the Power Architecture Notebook project, Libre-SOC project ( aims to deliver a physical POWER compliant SOC with a CPU, GPU, VPU, and DDR controller and others projects of cheap Power Architecture motherboards.

The debate on how to deploy applications, monoliths or micro services, is in full swing. Part of this discussion relates to how the new paradigm incorporates support for accessing accelerators, e.g. GPUs, FPGAs. That kind of support has been made available to traditional programming models the last couple of decades and its tooling has evolved to be stable and standardized (eg. CUDA, OpenCL/OpenACC, Tensorflow etc.).

On the other hand, what does it mean for a highly distributed application instance (i.e. a Serverless deployment) to access an accelerator? Should the function invoked to classify an image, for instance, link against the whole acceleration runtime and program the hardware device itself? It seems quite counter-intuitive to create such bloated functions.

Things get more complicated when we consider the low-level layers of the service architecture. To ensure user and data isolation, infrastructure providers employ virtualization techniques. However, generic hardware accelerators are not designed to be shared by multiple untrusted tenants. Current solutions (device passthrough, API-remoting) impose inflexible setups, present security trade-offs and add significant performance overheads.

To this end, we introduce vAccel, a lightweight framework to expose hardware acceleration functionality to VM tenants. Our framework is based on a thin runtime system, vAccelRT, which is, essentially, an acceleration API: it offers support for a set of operators that use generic hardware acceleration frameworks to increase performance, such as machine learning and linear algebra operators. vAccelRT abstracts away any hardware/vendor-specific code by employing a modular design where backends implement bindings for popular acceleration frameworks and the frontend exposes a function prototype for each available acceleration function. On top of that, using an optimized paravirtual interface, vAccelRT is exposed to a VM’s user-space, where applications can benefit from hardware acceleration via a simple function call.

In this talk we present the design and implementation of vAccel on two KVM VMMs: QEMU and AWS Firecracker. We go through a brief design description and focus on the key aspects of enabling hardware acceleration for machine learning inference for ligthweight VMs both on x86_64 and aarch64 architectures. Our current implementation supports jetson-inference & TensorRT, as well as Google Coral TPU, while facilitating integration with NVIDIA GPUs (CUDA) and Intel Iris GPUs (OpenCL).

Finally, we present a demo of vAccel in action, using a containerized environment to simplify configuration & deployment

• [1] https://blog.cloudkernels.net/posts/vaccel
• [2] https://blog.cloudkernels.net/posts/vaccel_v2
• [3] https://vaccel.org
• [4] https://github.com/nubificus/docker-jetson-inference

2020 was a very bad year for most of us, under the shadow of all that was going on there was a troubling trend we all need to be aware of: the erosion of the classic open source model and values. For years vendors have been slowly chipping away at the freedom and openness provided by open source, this year saw unprecedented changes to how people view and value OSS. From licensing changes to as a service exclusive, what was open is no longer. Is this being driven solely by the cloud? or is this purely corporate greed and others viewing open Source as a successful business model to replicate? Let's not only discuss but bring to light the trouble trends that threaten open source projects and development as we know it.

"[W]e didn't open source it to get help from the community, to make the product better. We open sourced as a freemium strategy; to drive adoption." - MongoDB CEO Dev Ittycheria

Open source was never designed or planned to be used as "Gateway Drug" to move people to a proprietary locked in software, but more and more this is happening. This is not just a MongoDB move; Elastic, Redis, and others have all used the "Cloud" as a convenient excuse to erode classic open source licenses and values. At the same time new "open source compatible" versions of popular projects like MySQL or PostgreSQL pop up on cloud providers platforms. It's like the game "Among Us" only with your open source projects. You never know who or what is really open until you dig deep.

Julian and I work for Icinga and want to shed some light on what, how and why we do what we do and also what YOU can do. The format is going to be a bit like a podcast, where we just talk about our topics for a little and try to provide some light entertainment while staying technical.

We were thinking of covering the following topics:

1. What is Icinga
2. what can Icinga do for me?
3. Where do our strengths (and weaknesses) lie?
4. How does our development work at the moment?
5. Which direction would we like to go with it?
6. How can someone contribute to the project?

schema-collaboration is a tool that helps data managers and researchers to collaborate on documenting datasets using Frictionless Data schemas. It uses Frictionless Data Package Creator and allows the collaborators to create and share dataset schemas, edit them, post messages and export the schemas in different formats (text, Markdown, PDF). The tool is implemented in Python and Django.

The talk will consist of a brief explanation of Frictionless Data schemas, how data managers work with researchers and then I shall do a demo of how the tool can be used.

Embedded development is complex enough. By automating repetitive parts during development and employing testing, a lot of time can be saved and human errors avoided. Additionally, embedded development is usually a team effort: scarce hardware must often be shared between developers and sometimes even with automated testing. labgrid is an open source tool for remote control and testing of Embedded Linux Devices in a distributed lab. In this talk the presenter takes a look at how labgrid can be used in your Embedded lab and what labgrid's developers have learned in over three years of using and developing it.

At first the presenter takes a closer look at what is actually needed to fully remote-control an Embedded Linux Device: What are the typical interfaces that need to be covered? What remote-control hardware is commercially available?

Next the presenter will focus on the labgrid [0] framework. Labgrid is an embedded board control python library, with a focus on testing, development and general automation. After a short overview of the key design-concepts the presenter will discuss labgrid's architecture. This part finishes with a demo of how interactive development with labgrid looks like and how tests are implemented using pytest.

The talk will conclude with a lessons-learned with the joy and tears of over three years of active labgrid development and use.

Synchronous or quorum replication is the basis of the modern HA cluster. At Yandex.Cloud we are using replication-based HA PostgreSQL clusters for many years. In this talk, we want to introduce basic concepts and highlight caveats that seem important to us.

Ever wanted to write an emulator? Or understand how they work? In this talk you learn how to start writing your own emulator from the ground up. You'll see the basic methods used to emulate CPUs, memory, and graphics cards. For the keen, we'll also cover advanced emulation techniques, licensing issues, and history.

There are a lot of old machines in the world, many are literally falling apart, and out of the consciousness of the programmers who once built them. But all deserved to be remembered. That's why we need more emulators developed in the open, so the knowledge isn't lost to history. By showing how easy it is, we hope to encourage others to do the same, regardless of their language of choice or which old computer they want to resurrect.

With worked examples, live demos, and new games, there is a lot of easily accessible code to see, and advice on how (and where) to start writing emulators.

The speaker is prolific developer Steven Goodwin who created the EMF emulator framework, and wrote 9 emulators during 2020. He is also a computer historian and part of the Centre for Computing History in Cambridge, England.

The presentation will cover different ways to communicate across browsing contexts. The main 2 approaches are - 1. Shared memory - Localstorage, Cookies, SessionStorage, IndexedDB, SharedArrayBuffers & Atomics 2. Messaging- Postmessage, BroadcastChannel, MessageChannel

The presentation will show a demo of usage for each of the types and explain the use-case, advantages and disadvantages for them.

'No-Code/Low-Code' software by Tiki.org has blurred the lines, allowing for team member participation and engagement on digital and data initiatives on many levels. It goes well beyond many CRM, ERP, PM, etc, offerings which are good at what they do but typically narrow in focus, by giving users a wide mix of hundreds of tools in many categories - Front-end, Back-end, Databases, Admin and Mobile. Big 'Features', supporting 'Features' and countless small but handy plugins all combine, allowing users to literally create any app for any business sector. This less focused and 'utilitarian' nature is more relevant than ever as Tiki resolves a problem so many organizations today are struggling to solve - too many apps with little to no integration between them. Tiki offers so much, in fact, that it allows individuals to become Full Stack Developers - this is my story and where I'm at after using Tiki for over 8 years. However, since it's FLOSS software it also fits developers like a glove, as unlike proprietary 'No-Code/Low-Code' offerings where even developers would need to submit Bug Reports and wait for responses, Tiki allows them to get 'under the hood' and debug complex configurations at their convenience.

This presentation briefly covers a few 'No-Code/Low-Code' development tools in each of the 5 categories that Full Stack Developers need, various user roles and the levels on which they can participate as well as gives examples of 'No-Code' and 'Low-Code' within Tiki.

Instruct the audience for achieving high throughput online exports of charged events with in-memory data only.

In this talk Teo will present the mechanisms implemented to achieve straight in-memory processing with online exports for events to be charged by CGRateS, without the need for further storing them. Following CGRateS modules will be covered: ERs, SessionS, CDRs, RALs, AttributeS, EEs. CGRateS is a battle-tested Enterprise Billing Suite with support for various prepaid and postpaid billing modes.

Data Processing Units (DPUs) and SmartNICs--these things are getting a lot of attention, particularly in the network storage world. There's a bit of history behind them, particularly if you consider TCP Offload Engine (TOE) cards and iSCSI NICs, both of which have been around for quite a while. This latest wave, however, is more general-purpose by design and presents an opportunity for developers like us.

DPUs are typically, but not necessarily, built around ARM cores. They are the engines that power the current cavalcade of SmartNICs, and are also being integrated into server-class mainboards. In any case, they are going to be a feature of the next generation of storage platforms, application servers, and cloud infrastructure systems. This talk centers around work to implement NAS Offload, particularly SMB3, for SmartNICs. We'll expand from there to discuss how NAS Offload can be leveraged for Software Defined NAS services, and will also consider what DPUs might mean for distributed object storage. The doors are wide open to Open Source development community, and this is an opportunity we cannot afford to miss.

If you can't modify the root filesystem of your distro (no, not even with sudo!!), you can't break it, right? Well... soft of. But what's the price to pay in terms of usability? How are you actually able to use an OS like that for common everyday user (web browsing, document editing) and developer (writing and building code) activities? Come to this talk and learn how it's being to use one of them, i.e., openSUSE MicroOS, as a daily driver since the last few months and how that compares with using other similar solutions, like Fedora Silverblue and Endless OS.

An Immutable OS is a GNU/Linux distribution where the user has limited (if at all!) changes to modify the root filesystem. And by "modify the root filesystem" we mean doing things like installing software with the package manager. Some examples of Immutable OSes that falls in this definition are Fedora Silverblue, openSUSE MicroOS, openSUSE Kubic and EndlessOS. In fact, on Fedora Silverblue, the user can't add software with dnf, not even after becoming "root". Similarly, on openSUSE MicroOS, zypper install just does not work. This brings the advantage of keeping the OS cleaner, consistent, reliable and a lot harder to break. For instance because what developers produce and tests is a lot more similar to what actual users use, with respect to what happens with "traditional OSes". And they usually come with a nice way of rolling back changes too, which is also really valuable.

But what are the technologies behind all that? Well, there are a few, and although the outcome is rather similar, their inner working and characteristics are quite different. In this talk, we will focus on two: ostree and transactional-update. The forme is used in Silverblue and Endless OS, the latter in openSUSE MicroOS and Kubic. We will try to provide a description of how both work and what are the main differences between them.

Even more important: what's the user experience with such distros? And what if one is not only a user, but a developer? Well, this talk will offer a perspective of how it is being to use one as one's own daily driver, for both user-like and developer-like tasks. That would be openSUSE MicroOS. We will cover what it is the current status of the "MicroOS as a Desktop" project, what are the current challenge and the upcoming developments. But we will also try to hint at how the user/developer experience may vary between MicroOS and others (more mature) immutable desktop solutions like Fedora Silverblue and Endless OS.

You need to migrate some workloads from a private datacenter to public cloud. The result? The unavoidable hybrid environment. How do you observe traffic and mitigate risky changes to each system? In this talk, I’ll discuss how you can supercharge your cloud migrations with a combination of network automation for your datacenter and a service mesh across environments.

You need to migrate some workloads from a private datacenter to public cloud. The result? The unavoidable hybrid environment. How do you observe traffic and mitigate risky changes to each system? In this talk, I’ll discuss how you can supercharge your cloud migrations with a combination of network automation for your datacenter and a service mesh across environments.

How to Migrate to Cloud, Supercharged

Step 1: Re-platform application on public cloud.

Step 2: Deploy service mesh in public cloud and edge of datacenter.

Step 3. Configure datacenter routing with network automation.

Step 4: Send traffic using blue/green deployment to the new application.

Step 5: Continue to run in both datacenter and public cloud.

I’ll demonstrate how to add observability and failure tolerance to this workflow. By combining HashiCorp Consul service mesh and Consul Terraform Sync, I can manage, automate, and shape traffic in my hybrid environment from a single pane of glass.

Getting started guides for application development with databases are important for learning the basics. Naturally they tend to target ease of understanding. However, these choices for simplicity can make it hard to scale or operate without downtime once your application starts to grow. This talk aims to cover a few things you and your team can start doing to help lay a foundation for growth and flexibility.

Raku is an amazing programming language, but many examples online are very complex and can be hard to follow. This talk highlights some amazing features of Raku, but assumes zero knowledge of the language.

At Azul, we have spent some time to create a little API that should help you to discover builds of OpenJDK from different distributions in a general way.

In this session, we will give you a short introduction on what the Disco API is and how it can help you finding the JDK/JRE of your choice.

At the moment the API can help you getting builds of OpenJDK from the following distributions: AdoptOpenJDK, Corretto, Dragonwell, Liberica, Oracle OpenJDK, SAP Machine, and Zulu.

The localization process for Apache OpenOffice

The localization prozess for Apache OpenOffice

An Anatomy of an improvement

This presentation illustrates how the GNU Emacs text editor provides an powerful integrated environment for reproducible research, effectively bypassing the need for juggling different software in order to write and execute code, manage data or write papers. GNU Emacs as a long history, and is still widely used and supported by a very active community of users and developers. A very popular feature of GNU Emacs is Org-mode which, at its core, offers a markup language similar to Markdown.

Following a brief introduction to Org-mode, this presentation demonstrates its use for reproducible research: straightforward mixing of prose and code, execution of code blocks as well as display of the results. With Org-mode, GNU Emacs is turned into a computational notebook which functionalities goes well beyond popular alternatives such as Jupyter. Code blocks are not restricted to a particular programming language and data can be passed between them: generate data in C, analyse it in Python, visualise it with R, all in one single executable document. Moreover, Org-mode documents are nothing but plain text, making them inherently portable, sustainable, and suited to version control - crucial qualities for academic research. Moving on, I illustrate the export of Org-mode documents to richer formats: PDF, ODT, HTML and many more - all from within GNU Emacs. Lastly, I broaden the scope of this presentation and discuss the open nature of GNU Emacs itself. Indeed, GNU Emacs is free (as in freedom) software under a copyleft license. This ensures that GNU Emacs remains sustainable, community-owned software: GNU Emacs will never be "discontinued" or its features reduced inside a "community edition".

If GNU Emacs is widely used among GNU/Linux users, it is a rather unusual component of nowadays researchers' toolbox. This presentation is an opportunity for attendees to (re)discover GNU Emacs, not so much as a code editor, but as a powerful tool for reproducible research, from day-to-day data collection and analysis, all the way to paper publication. Despite being over 30 years old, GNU Emacs comes with with very modern ideas, highly relevant to today's discussions of openness and reproducibility in scientific research. Beyond the tool itself, this presentation is an opportunity to sparkle discussions on the nature of research tooling. GNU Emacs has always been developed and maintained in the open, and its license ensures that it will always be. GNU Emacs maintenance and development is a collective, not-for-profit effort of thousands of developers worldwide and anyone wanting to make modifications to it is welcome to do so. This ensures both reliability and sustainability, which are key characteristics for any tool at the core of a reproducible research practice.

With the advent of Zoom's questionable use of the term "End to End Encryption" many turned their eyes to FLOSS solutions. Thanks to the insertable streams feature which shipped in Chrome at just the right time, we were able to ship a working E2EE implementation in a reasonably short amount of time.

In this presentation we'll walk through all that was needed, what our plans for the future are and how others can leverage what we learned to add E2EE to their WebRTC applications.

Notcurses is a C library (with C++, Python, and Rust wrappers) facilitating complex TUIs on modern terminal emulators. Notcurses supports vivid colors, multimedia via FFmpeg or OIIO, sane multithreading, and complex Unicode. Things can be done with Notcurses that simply can't be done with NCURSES or any other implementation of the X/Open Curses specification. I will present Notcurses's design goals, API, and some details of its implementation, which ought serve as a sufficient grounding for any potential Notcurses developers. Your terminal emulator is more powerful than you have ever dreamed.

Notcurses 2.1.0 was released in December 2020, about thirteen months after the repository's first commit. It is available from many Linux distributions, as well as the FreeBSD Ports Collection. It is used by the author's "Growlight" block device manager and "Omphalos" network discover tool, as well as other projects. It aims to be a superset of existing TUI libraries' functionality, while achieving and enabling higher performance. A comprehensive reference, "Hacking the Planet with Notcurses", is available for paperback purchase or free download (Apache-licensed XeLaTeX source is also available). Notcurses has been featured on LWN and at the Debian Gaming Miniconf.

Welcome to Scuttlebutt!

A walkthrough and introduction to the Scuttleverse. Here we explore real life projects and guide you in connecting with the main network. A hands on workshop for those looking to try out Scuttlebutt.

Like other social platforms, you can send messages to your friends and share posts onto a feed. The cool thing is that the underlying technology here means that messages are passed directly between friends via a peer-to-peer (p2p) gossip protocol.

As a decentralized social network, Scuttlebutt passes the data from friend to friend, without any central server. The data is localised and distributed so it also happens to work offline!

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 description of what changes Homebrew needed to make to get working on macOS 11 Big Sur and what work we've done and are doing to support a new CPU architecture for the first time since Snow Leopard.

Providing details of the biggest changes that Homebrew users have been excited about in the last year: support for Big Sur and the ongoing work for ARM. Provide technical details on what's required for us to support a new operating system from Apple and what the entire Homebrew ecosystem needs to do/change in order to support a new architecture. Nearer the time we'll also be able to provide a status report on how near we are to "official" support.

Long gone are the times of executing the OS in-place from memory-mapped flash upon reset. A modern SoC now comes with complex mask ROM firmware, with driver, filesystem, protocol and crypto support for loading... yet another bootloader.

In his talk, Ahmad follows this chain of bootloaders until the kernel is started, stopping along the way for RAM setup, peripherial initialization, runtime services and other interesting sights.

Getting acquainted with the bootstrap process on a modern ARM-based SoC can be an intimidating task: Documentation speaks of Boot ROM, blobs, SPL, secure monitor, trusted execution environment, Open Firmware Device Trees all interacting with each other and with a bootloader to facilitate kernel boot.

The talk intends to shed some light onto this. Starting with an overview of the bare minimum needed to bootstrap an i.MX8M, it retraces the steps of the barebox bootloader, and firmware loaded by it, until Linux eventually takes over.

A talk about Thunderbird's journey in 2020 and 2021.

Void's POWER architecture port has been progressing steadily since the last OpenPOWER Summit EU talk in 2019. Recently we introduced a completely new 32-bit little endian port, which will be a big part of this talk's focus, and is a first among Linux distributions. I will not stay there though - we have more to cover, including stuff like Chromium and Electron applications in repos, faster POWER crypto in LibreSSL, reworked crosstoolchains, stable support for newest AMD GPUs, and our big endian variants are also receiving attention, including properly clearing up the 64-bit ABI situation.

Void Linux is an independent, rolling release, general purpose Linux distribution (leaning towards desktop/workstation focus) originally created in 2008 on the x86_64 architecture as a testbed for its own XBPS package manager. Over time, it has received a variety of ports, including 32-bit and 64-bit ARM, MIPS, and eventually POWER and PowerPC. It has variants for 64 and 32 bits, little and big endian, and glibc and musl C standard libraries. Most recently it has received an experimental 32-bit little endian port, which is a first among Linux distributions.

I will be focusing partially on the new port, and partially on other news in the distribution since my last talk I gave at OpenPOWER Summit EU 2019. I will explain our goals with the new port, as well as our plans. Additionally, the future of the distribution will also be covered, as well as currently remaining issues and blockers that prevent us from achieving that.

The "pet vs cattle" thing is getting pretty long in the tooth, but the one thing one keeps hearing is that the management layer somehow always remains a pet.

While there is certainly some truth to that - you don't want to rebuild your management plane every day - wouldn't it be cool if you could?

The "pet vs cattle" thing is getting pretty long in the tooth, but the one thing one keeps hearing is that the management layer somehow always remains a pet. While there is certainly some truth to that - you don't want to rebuild your management plane every day - wouldn't it be cool if you could? In this talk we will show how to fully automate the deployment and configuration of Foreman using Ansible, which allows for reproducible setups, redeployments and testing environments that actually match production. The presented solution should not (and can not) replace working backups, but it might still save you when the restore isn't going as expected or someone asks to start "fresh" while keeping all the important details the same as before. We will show how to deploy Foreman from scratch in an reproducible way, reusing the same bits the project uses itself. This will also include plugins like Katello and Ansible for best possible client management later. We'll continue with integrating Foreman with compute resources and managing content in Katello, which will result in trivial deployments of further cattle systems from Foreman, which then can be managed via Ansible. The result is a set of playbooks that can be stored in a git repository and deployed at will.

How I reverse engineered an off the shelf smart watch in order to create Bangle.js, a watch that runs JavaScript. I'll cover the process as well as some of the hacks Espruino employs to run JS on a device with only 64k of RAM!

Operator SDK is a solid foundation for building robust applications for Kubernetes; one of such applications is the VM import operator (https://github.com/kubevirt/vm-import-operator) allowing Kubernetes administrators to easily import their oVirt-managed virtual machines to KubeVirt. In this talk, the speaker will show how his team used Operator SDK to build the VM import operator and how that operator can be used.

The Kubernetes is on a rise and thanks to its capabilities many developers and administrators want to migrate their workloads there, which not always is possible right away or easy to do.

VM import operator can help in decomposing any applications previously running in oVirt. If the current deployment doesn’t allow for that, Operator SDK can ease the burden of either migrating existing applications to a new stack or building tools that can allow existing software to run in a completely new environment.

The attendees will: - learn basic principles guiding development with OperatorSDK; - learn how VM import operator works; - know how to import their oVirt workloads to Kubernetes, hassle-free.

Do you feel like you don't belong, you don't deserve what you achieved, everyone in your office is more talented than you? Do you have imposter syndrome... too? Imposter syndrome is common across all industries, but the increasing pressure to be successful in IT is taking its toll on employees, affecting more than half workers, me included :) After many years working in tech for a lot of companies (from startups to big corporations) in many business fields, I found a way to overcome self-doubt and turn this weird feeling in a booster for greater achievements... and I want to share it with you!

A short overview of the OpenChain project, its purpose, goals and the current state

We will introduce the project, its current state, especially the ISO adoption, give a short overview of the requirements and link to the different certification schemes. Finally we will expose the working procedures and link the international working groups.

Resilience is often touted as the biggest advantage of component-based systems over monolithic architectures. The catchy part of the story often told is the containment of faults via sandboxing. However, the story has another inconvenient side that often remains untold. Components are interdependent. Whenever a central low-level component fails, dependent software stacks suffer under the outage. The talk presents Genode's recent breakthroughs to address this second part of the story, in particular making the system resilient against flaky device drivers.

Component-based operating systems promise the containment of software faults and vulnerabilities by separating functionality into sandboxed components. In practice however, a contained fault is still a fault. Whenever a fault happens in a central server component, clients have to suffer under the outage of the server.

Device drivers are especially problematic because they tend to be fragile while being a hard dependency for critical software stacks on running on top. Even though a bug in the driver cannot subvert the information security of the dependent components, it cuts the lifelines of those components.

This fundamental problem calls for an architectural solution. We found the key in the reversal of the dependency relationships for several classes of device drivers. During this line of work, we re-stacked Genode's low-level GUI stack and turned network device drivers into disposable components. Thanks to these changes, drivers for framebuffer, input, network, and wireless devices can now be started, killed, updated, and restarted at anytime without disrupting applications.

The talk provides a holistic view of Genode's recent architectural changes, gives insights into the though process, outlines the methodology applied for turning big parts of the system upside down, presents limitations, and gives an outlook to the future of Genode and Sculpt OS.

Crash safety is one of the requirements of modern databases. Although DML is crash safe (depending on storage engine), DDL is still problematic. MariaDB 10.6 will implement atomic DDL. Currently RENAME and DROP are fully supported for all database objects and the goal is to implement all remaining operations. This talk will go into the technical details of the atomic DDL implementation, explaining how it provides crash safety.

Telegraf is an agent for collecting, processing, aggregating, and writing metrics.

With over 200 plugins, Telegraf can fetch metrics from a variety of sources, allowing you to build aggregations and write those metrics to InfluxDB, Prometheus, Kafka, and many more targets.

In this talk, we'll take a look at the different plugins Telegraf provides for collecting metrics about our networks, as well as the latest features of InfluxDB 2 that make sharing our configurations with others a piece of cake.

Lets get started

eLabFTW is an open source laboratory notebook for research labs. It tracks experiments and results but also features a database where you can keep track of all the elements in your lab. Created in 2012 and published on GitHub, eLabFTW quickly gained traction in the research community and several contributors joined over time to help implementing new features and fixing bugs. Now translated in 17 languages, eLabFTW has become a pillar of the ELN landscape and more and more labs and universities are using it all around the world.

In this presentation I will talk about the software itself but also how publishing the source code on GitHub with a AGPLv3 license helped tremandously the software to grow.

When doing research work, it is important to keep track of your experiments and results. To do that, we normally use paper lab notebooks. But nowadays, it makes little sense to stick to paper, especially when all of our results are produced in a numeric format. Users are now looking for a solution to that problem, and that solution is Electronic Laboratory Notebooks (ELN).

Several ELN are available to researchers. Some are proprietary, and only a few are truly free (as in beer and as in speech). Among the libre ones, we can find quite a lot of abandoned projects.

Since 2012, eLabFTW has seen continuous improvements with a constant flow of new features and a growing community of users, translators and contributors. It is now a mature and polished piece of software, widely used by startups, research labs and universities.

Now backed by a company, the future seems bright and full of promises with fruitful collaborations with Universities to implement specific features that will benefit the whole community of users.

OpenHarmony is a new operating system stewarded by Huawei's Open Source Technology Center, with Array as advisor. Having prioritized compliance, governance and transparency, OpenChain was the natural backdrop for it. Rather than embracing open source only to exploit it, having transparency and compliance as a last minute afterthought, OSTC has made them central pillars from the very beginning. We seek the opportunity to present you how the goal of OpenChain conformance helped.

Born as an internal project, since its conception OpenHarmony's future has been to live in an independent, respected foundation that will receive all the tool for keeping it a truly community-driven operating system. The tools that Will be donated do include a compliance toolchain with source code scanning, compliance policy documents and roles, a Bill of Material for the initial release and many other artifacts to make it sure compliance is not a one-off exercise, but an ongoing commitment for the entire life of the project. Full conformance with Openchain is projected in a short-term future and it is surely a motivation to start with the right steps and making the right choice off the very beginning of the project.

Spending a short time working as a barrister opened my eyes to a profession that is hundreds of years old. In comparison to the legal profession, the computing profession has barely got started!

This talk is a mash up of when these two worlds collide. As professional Perl and Raku programmers are there any cool hacks we can borrow from the arcane world of barristers? Which practices could help power Perl and Raku for the next hundred years?

A look at the challenges facing us in the world of free communications and the practical steps we can take today to move forward.

With containers being deployed at scale on Kubernetes, there is more than ever the needs of introducing proper Secrets management to address in and out services. While there are dozens of Network related open source projects, there is not much about the art of Secrets and almost none being to be part of the Cloud Native Computing Foundation landscape. This talk provides an overview of the open source state of Secrets management.

When deploying containers at scale by the hundreds or thousands, the Secrets management is always one of the most difficult topic to take on. Kubernetes by itself doesn't provide a real secure solution and any other solutions are either a pseudo open source solution calling for budget to move to the Enterprise version or calling for a true mental shift that scares Security Officers. This talk call provides an overview of these projects and concepts, why they are nice but sometimes scary.

SDKMAN is the Software Development Kit Manager. It is fast becoming the defacto standard for installing JDKs and other JVM related SDKs on the CLI. It's a Free and Open Source tool with the primary purpose to making developers' lives less painful!

This talk will begin with a demo of how SDKMAN can be used in your daily workflow. We will show you how to install multiple Candidate Versions side by side and how to switch between them. We will also look at some of the other functionalities that it offers. We will then take a peek under the hood and see how SDKMAN works both in the CLI as well as the serverside backend.

Finally, we will take a look at other aspects of what SDKMAN brings, including Vendoring, Community Contribution and Future plans.

If you really don't know what SDKMAN is, or if you would like to have a peek under the hood at what it does or how it does it, this talk is a must for you!

LINSTOR enables the automation of the deployment of block storage that is replicated over multiple storage nodes and can act as a software defined storage provider for various container and virtualization platforms, such as Kubernetes, OpenStack, OpenNebula and Proxmox. It also includes additional storage features, such as the automation of storage encryption, deduplication or the automatic creation of file systems on new block storage volumes.

Keeping work organized in experimental materials science research is a nightmare. Projects involve data collected with dozens of different instruments on dozens of different samples that are related to eachother in a hierarchical fashion. For each new project, researchers struggle with questions like: how should I organize my files and data? How should I name my samples? How should I keep track of the links between data and samples? Since no standard answer to these questions has been formulated, labs and individuals just improvise. The result is that most data and samples become utterly useless once the person who conducted the research leaves; no one else can find their way through the ad-hoc naming conventions and various excel sheets. This eventually translates into a lot of wasted and repeated efforts.

The biological sciences have long ago figured out solutions to these problems, and they are lab information systems (LIMS) and digital lab notebooks. In this talk I will present how I organize my research workflow in eLabFTW, a free and open source lab notebook with some LIMS capabilities. The tool was originally developed with molecular biologists in mind, but most of the tooling is useful for materials scientists. I will also talk about how I could leverage the python API for tailoring the tool to my needs, for example for printing QR-code stickers for database items.

MariaDB has had roles all the way back in 10.0 (2013). MySQL now supports roles as well, starting with 8.0. This talk will go through an overview of Roles in MariaDB and how they can be used. The talk will also highlight the differences, as well as the migration requirements, should you need to move to (or from) MariaDB.

Roles in MariaDB follow the SQL Standard implementation. Roles are a very useful feature for ensuring ease of use for a DBA. Not only that, but thanks to DEFAULT ROLE, applications not previously aware of roles can make use of them transparently.

In this talk we will cover the following aspects of Roles: * Creating, granting, activating. * Roles granted to roles (the role graph) * Default Roles * Information schema tables * Differences to MySQL, migration with mariadb-dump.

With the global pandemic, many teams have turned to remote work on a full-time basis. Prior, the XWiki team had been working distributively, building open-source software, for over 15 years. Some of us were working remotely full time. Other colleagues opted to go to the office. The majority of the team chose to blend the two, depending on their preferences and needs. Almost a year on, what seemed a temporary change feels like a permanent arrangement.

Being able to work entirely remotely has been, in many ways, a privilege. But collaborating during a pandemic is not business as usual. This talk reflects on the specific challenges we faced, the changes and tools we implemented to address them, and the ways we tried to support each other through this uncertain period. While there’s no one size fits all, we hope sharing our experience will prove useful for teams navigating similar challenges. We’re in this together.

CryptPad is an encrypted and open-source collaboration suite. One year ago I joined the team as a designer. In this talk I will present some of what has been achieved and reflect on the challenges ahead.

When I joined CryptPad in November 2019, the project had already been operating for a few years. Like many open-source projects it was lacking on the design front and I was brought in to "improve the user experience". This broad task takes on many forms, but they all boil down to one thing: improving communication. Whether in UI design, UX writing, answering support tickets, writing documentation, or visual identity, all of my work to date has been about how CryptPad communicates. I did not set out to re-invent everything from scratch but rather aimed to consolidate what was already there and to make the software more legible in a broad sense. This includes the strategy for implementing design changes gradually, negotiating immediate demands (e.g. implementing a new feature) and longer-term ambitions (e.g. rebranding) all while adhering to the release cycle. In this talk I will highlight examples of design improvements achieved this year, from specific features to the release of our documentation and our upcoming 4.0 release with a new visual identity. I will also reflect on the next major challenge: accessibility.

There are many Linux distributions out there - and almost as many different approaches to how they're built. Two distributions on nearly opposite ends of the spectrum include OpenMandriva (which uses binary packages, builds and updates each package individually, applications are part of the OS, ...) and OpenHarmony (which builds the OS from source in one go, is updated through OTA images, and treats applications as something separate, ...)

A developer involved in both projects explains how the 2 projects go about building their respective OSes, why both projects made the choices they made, how the approaches differ from a developer and user perspective, and what approach works better for what particular use case.

In this talk we want to present how Microsoft team composed of people from two different teams approached the project and solved the migration issues using ora2pg and was able to prove that Postgres Single Server can perform equally well as Oracle Exadata. We will present our ways of working and also some main technical challenges that we faced including migration of BULK COLLECT’s, hierarchical queries, refcursors and others more complicated Oracle constructs.

The story about a challenging PoC that proved that Postgres can achieve the same performance as Oracle Exadata. The schema that was migrated wasn’t the simplest one you might see. It was quite the opposite. The code was loaded with dynamic queries, BULK COLLECT’s, nested loops, CONNECT BY statements, global variables and lot of dependencies. Ora2pg did a great job converting the schema but left a lot of work to do manually. Also estimates produced by the tool were highly inaccurate since the logic required not the migration but total re-architecture of the code. In this talk we want to present how Microsoft team composed of people from two different teams approached the project and solved the migration issues using ora2pg and was able to prove that Postgres Single Server can perform equally well as Oracle Exadata. We will present our ways of working and also some main technical challenges that we faced including: • How estimates do (not) work • How we handled BULK COLLECT’s • Why we got rid of refcursors • How we got stuck with testing of one the packages and how the help from a friend solved the problem • How we handled hierarchical queries and drilling down the hierarchy

Even to this day, there's something utterly captivating about bringing to life a piece of software effectively frozen in time, designed to run on what was originally a black box, by means of a device that one uses to check up on cat facts. Adding to this, it can even be enhanced and possibly perform better than its developers ever hoped for.

If you also got to play around with your first computer in the early 2000s, chances are that console emulators were amongst the first pieces of software you've ever run on a computer. Submitting this talk was an endeavour to explore this unexplainable (or is it?) fascination by what seems to conceptually be a compatibility layer. More importantly, the talk aims to have you intrigued about emulation development and the scene in general in the year 2021, by presenting the significance of the emulation community in the context of education and history preservation.

It will also highlight how emulation development is more accessible today compared to the early days of the likes of PSEmu Pro, Project64 and NO$GMB - thanks, in no small part, to the FOSS community.

TLDR: this will focus on the "why" (rather than on the "how") you should have a go at writing your first emulator.

Additional info:

The intention is to provide people that can relate to the below points...

• solid programming background and grasp of computer science fundamentals
• naturally curious about the inner workings of computers
• a general interest in console history
• a little too sceptical as to what business they could have entering territory of the emudev Gandalfs of the 2000s that they looked up to during their school years
• [optional, but desired] having fond memories of their (even-then) ancient Pentium 3 struggling to handle Tekken 3 on bleem!
• (you get the picture)

... with good reasons as to why dipping their toes in emulation development is worth their time, and how writing an emulator is an awesome all-around learning experience, out of which you'll become a better engineer.

Plus, amongst other, to highlight how such a journey is meaningful, rewarding and worthwhile -- as it lies within context you can relate to: seeing your childhood games come to life (or, on the remaining 99% of occasions: using the debugger that you wrote trying to figure out why you can't get past the first screen)

This is the continuation of the "Status of AMD platform in coreboot" presented last year on the Open Source Firmware, BMC and Bootloader devroom. The talk will cover the news around the AMD support in Open Source Firmware ecosystem from the past year. You will hear, among others, about: FSF RYF KGPE-D16 platform revival, AMD Ryzen R1000/V1000 series AGESA integration into open source TianoCore EDK2, TrenchBoot new features and updates and current support of AMD Picasso and Cezanne SoCs in coreboot, pure open-source on AMD Rome platform in oreboot.

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 introduce the history of AMD and coreboot, the evolution of the code, processors, creation of CIMX and AGESA and so on. It will also show the gradual change in the AMD attitude to open-source and introduction of binary platform initialization. Binary blobs, very disliked by the open-source community started to cause problems and raised the needs for workarounds to support basic processor features. Soon after that AMD stopped supporting the coreboot community. 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) are being dropped from the main tree. Nowadays AMD released the newest AGESA with the cooperation of hired coreboot developers, but only for Google and their Chromebooks based on Ryzen processors. 3mdeb trying hard with this ecosystem showing that the AGESA can be integrated into Open Source Firmware like TianoCore EDK2 on the example of AMD Ryzen R1000/V1000 processor. Even FSF RYF KGPE-D16 platform is experiencing its second youth by being revived to the main coreboot tree. If you are curious about these activities and many more like TrenchBoot new features or AMD Picasso an Cezanne SoC support in coreboot, pure open-source on AMD Rome in oreboot, this presentation is for you.

SPARK is an open-source tool for formal verification of the Ada. language. Last year, support for pointers, aka access types, was added to SPARK. It works by enforcing an ownership policy somewhat similar to the one used in Rust. It ensures in particular that there is only one owner of a given data at all time, which can be used to modify it. One of the most complex parts for verification is the notion of borrowing. It allows to transfer the ownership of a part of a data-structure, but only for a limited time. Afterward ownership returns to the initial owner. In this talk, I will explain how this can be achieved and, in particular, how we can describe in the specification the relation between the borrower and the borrowed object at all times.

Previous work such as Plundervolt has shown that software-based undervolting can induce faults into Intel SGX enclaves and break their security guarantees. However, Intel has addressed this issue with microcode updates.

We later discovered that there is a physical connection on the motherboard which allows us to control the voltage and conduct fault injection. In this talk, we will present a low-cost device: Voltpillager, which use this physical connection to break the guarantees provided by SGX again.

On a standard motherboard, there is a separate Voltage Regulator (VR) chip that generates and controls the CPU voltage. Our tool, VoltPillager, uses this to connect to the (unprotected) interface of the VR and control that voltage. Based on this, we then mount fault-injection attacks that breach confidentiality and integrity of Intel SGX enclaves, and present proof-of-concept key-recovery attacks against cryptographic algorithms running inside SGX.

Our results may require a rethink of the widely assumed SGX adversarial model, where a cloud provider hosting SGX machines is assumed to be untrusted but has physical access to the hardware.

Mercurial is a Distributed Version Control System mainly written in Python. While it is often the VCS of choice for monorepos for its great scalability, certain parts remain slower than they should be. Over the past two years, an effort to rewrite parts of the Mercurial core in Rust has seen multiple significant wins in performance, even compared to C implementations.

We will go over the different obstacles that Raphaël and his colleagues at Octobus faced during the rewrite of the ubiquitous hg status, and the solutions they came up with to make this command (and others) a lot faster. For example, running hg status in a Mozilla working copy moved from 1.1s to 0.04s, a ×25 improvement.

Themes covered include:

- Rust and Python interoperability
- Fast (and slow) Rust datastructures
- Fast directory traversal
- Version control internals
- Append-only binary formats
- Mtime caching
- Safe mmap usage in a concurrent context
- Multithreading
- Unix vs MacOS vs Windows issues

Container registries are becoming an important source of software distribution. Why package content in a container image? A container image includes an assorted collection of software - often hundreds of software components. This format facilitates use of the software, because a complete set of the needed components are delivered as a single unit.

In this talk we look into how to ship content regardless of how it is packaged (rpm, python, ansible roles) in a container image and build the image with just one single tool - Pulp3. With Pulp3 you will be able to take advantage of software distribution using the container first strategy :

• Containerize your application: build and run application in a container;
• Build execution environment images - which provide security features such as isolated execution and integrity of applications;
• Cache the content - allow container images to build without relying on external infrastructure by caching(or permanently storing) the application and dependencies.

Live panel Q/A with two speakers who spoke about the Elab software.

When Perl gained the ability to support custom keywords provided by modules it started down the path that CPAN modules would experiment with new language ideas. Already a number of such modules exist, and it is likely this idea will continue to develop. What new ideas might turn up in the next few years, and will any of them evolve to become parts of the actual core language?

Already we have real exception-handling try/catch syntax provided by Syntax::Keyword::Try, asynchronous code flow async/await by Future::AsyncAwait, and a still-experimental object system in Object::Pad. There are still many other commonly-requested or discussed features such as some sort of conditional case matching, multiple dispatch of functions or methods, or ideas around type assertions that could be applied by keywords as well.

At the same time, as these existing modules continue to provide useful semantics and gain more acceptance across CPAN authors and the wider community, we can begin to look at whether they can somehow be migrated into the core language entirely, becoming a true native part of Perl syntax.

Commonly used CI systems operate as SAAS solutions, where the user is not running the CI stack locally. This lends itself to debugging pitfall as developers cannot easily reproduce the problem locally and cannot interactively examine it. This talk proposes an inverted design, where self-operated CI tool can be used both in the cloud as well as locally, supporting interactive debugging sessions.

The recent surge of CI systems has created an interesting new problem, where a failure occurs in a specific test environment but does not appear in the familiar environment used by the developer.

This problem is compounded by the batch nature of such systems, where a developer can merely push additional patches to some branch to trigger an asynchronous execution process.

During the development of Ubuntu Core operating system, this problem was amplified by the fact building and testing a full OS image is a time-consuming process, leading to cycles that spanned hours and lead to frustration. Snapd developers created the spread program to solve this, among other, problem.

The SAAS solution became a thin wrapper around spread, which allocates, provisions, uses and finally discards the test environment. Crucially, almost all errors can be reproduced locally, as spread runs as a standalone tool, using QEMU, LXD, Google Compute Engine or Linode as executors.

This allows anyone to run spread locally, in interactive mode, and explore the problem without putting additional load on the centralized CI system, greatly improving the debugging process.

0 A.D. is a free and open-source game of ancient warfare. It is a real-time strategy game which can compete with the classics of the industry, but comes with absolutely no cost for the players. Come and discover your new favorite game!

I'll present a short story about graphics of 0 A. D. Why it requires math and algorithms, why water is the most expensive thing and why the Sun is watching you.

An introduction to the Zig programming language and the talks that will follow.

The LibreSOC hybrid 3D CPU-VPU-GPU is intended to provide a significant reduction in both hardware complexity, software (driver) complexity and systems integration primarily initially for embedded and mobile environments.

Larrabee or more specifically Nyuzi showed that a software-only "Traditional Vector Processor" architecture makes for a fantastic High Performance Compute Engine that, unfortunately, also turns out to have only 25% the performance/watt of current competitive embedded mobile GPUs. Not only that but SIMD, despite being (seductively) easy to implement by hardware engineers, has been shown to have harmful consequences at the software level (setup and loop end cleanup). A recent patch to glibc6 to add POWER9 VSX strncpy was a whopping 250 hand-crafted assembly instructions, where its equivalent using Cray Vector principles is around 14.

All of this was solved decades ago by Cray Vector designs, and then forgotten. Only now is variable-length Vectorisation being rediscovered and deployed in modern architectures: RISC-V RVV, ARM SVE2 and also Simple-V. This talk therefore goes through the background and concepts behind Simple-V. Thanks to a grant from NLnet, SV will be formally documented and proposed formally as an extension to OpenPOWER, for review by the OpenPOWER Foundation.

In this session, participants will get an overview of the new oVirt monitoring feature with its data warehouse (DWH) and Grafana, architecture and demo. The session will also cover the option of creating new dashboards based on the oVirt DWH schema. For creating new dashboards, attendees should be familiar with SQL querying.

The ReplicationWiki provides an overview of published empirical studies in the social sciences with information on data and code availability, data sources, and software. One can search for keywords, Journal of Economic Literature codes, and geographical origin of data. It informs about 670 replications, that is studies reanalyzing previously published results, as well as corrections and retractions. The wiki helps researchers to compare their results to those of previous studies. It is a resource that helps to identify useful teaching examples for statistical methods, replication and studies of social science. It allows advanced students and practicing researchers to find guidance on how to publish their replication research in various journals. A collection of teaching resources, useful tools, and literature helps instructors to integrate replication into their teaching and students to integrate open science practices into their own research. With the ongoing expansion of the wiki, currently covering more than 4,500 empirical studies, it is becoming an ever more powerful tool for social science research and education. It is a crowd-based platform where users can add their own replication results, suggest studies that should be replicated, and identify for example further data sources used in the empirical studies, especially ones from countries underrepresented in the literature and for whom economic policies are thus difficult to investigate.

The Wiki uses Semantic Media Wiki technology that is evolving, and a number of technical improvements in terms of usability and database structure are planned. A massive expansion of the content is planned based on machine learning and natural language processing techniques identifying the relevant information from the available data. For the technical improvements further expertise is welcome, and for the content expansion developers and researchers from all fields of the empirical social sciences are invited to join.

WebRTC was the technology everyone wanted to learn in 2020. With COVID and WFH new developers and companies came pouring into the scene. They had lots of problems making their vision happen. Many of them didn't even know what WebRTC was. When they figured that out they still had to make the long journey of figuring out how to build. This talk is my reflection of helping developerswith Pion WebRTC. WebRTC has so much potential. We just need to solve some technical, educational and cultural problems.

Out of those experiences we started WebRTC for the Curious and tried to make Pion easier to use. I also have some future ideas that I would love help from the RTC community.

Applications demand fast and secure execution in diverse environments (Cloud data centers, Edge Nodes, mobile platforms etc.). Execution efficiency has been facilitated by the introduction of specialized compute elements (eg. GPUs), in order to accelerate specific parts of tasks/workloads (such is image processing). At the same time, too abstract deployment and management burdens, service providers use virtualization and container technologies. Eliminating the software overheads of these abstractions, especially in the context of hardware off-load/acceleration is a challenge and requires a number of factors to be taken into consideration: (a) portability, (b) performance, and (c) security.

In this talk, we attack the first two factors and examine the option of unikernels and their surrounding ecosystem (application porting frameworks, orchestration frameworks, lightweight virtualization backends) in the context of hardware acceleration.

We present our efforts in porting a novel hardware acceleration framework, vAccel, to the rumprun unikernel, digging into the internals of semantic abstraction for ML inference, as well as its implementation on rumprun and QEMU/KVM. We describe the frontend/backend driver port, the runtime needed to support the actual execution on the hardware and showcase our results in a brief demo of two unikernel frameworks performing ML inference on images.

An introduction to techniques required to scale Naemon like Thruk, Mod-Gearman and LMD.

When companies and setups grow, network monitoring has to scale. This talk will walk you through an expanding and growing Naemon setup from city to global scale showing what will go wrong and how to mitigate those challenges. On the way, the tools Thruk, Mod-Gearman and LMD will be introduced.

Supported since Linux 5.10, the AMD SEV Encrypted State (SEV-ES) feature can be used to protect the confidentiality of a virtual machine (VM) by means of encryption and attestation. Although the memory and registers of the VM are encrypted, the VM still communicates with the hypervisor for the emulation of special instructions and devices. Because these operations have not been previously considered part of the attack surface, we discovered that a malicious hypervisor can provide semantically incorrect information in order to bypass SEV-ES. In this talk, I provide technical details on the handling of special operations with SEV-ES, practically show how the original implementation could be exploited, and finally I show how the interfaces were hardened to fix the issues.

This talk includes four different attacks which: 1) use virtual devices to extract encryption keys and secret data from a virtual machine. 2) reduce the entropy of probabilistic kernel defenses in the VM by carefully manipulating the results of the CPUID and RDTSC instructions. 3) extract secret data or inject code by forging fake MMIO regions over the VM’s address space. 4) trick the VM to decrypt its stack and use Return Oriented Programming to execute arbitrary code inside the VM.

The presentation will show how and why use UNION/INTERSECT/EXCEPT. How combine them to get expected result.

We will also dive into implementation details (with the help of the EXPLAIN command) to understand how MariaDB executes these set operators. This will help in understanding and troubleshooting performance problems.

drand and the associated league of entropy network is delivering periodically unbiasable and verifiable randomness over the internet. This talk presents how drand works, what is the current network, and the applications that can be realized using it. More info at https://drand.love.

Java build tools were developed before Java modules were around -- Bach builds (on(ly)) Java modules!

The JDK contains a set of foundation tools 1 but none of them guides developers from processing Java source files into shippable products: be it a reusable modular JAR file with its API documentation or an entire custom (soon static 2) runtime image. There exists an implicit workflow encoded in the available options of the foundation tools. The (binary) output of one tool is the input of one or more tools. With the introduction of modules in Java 9 some structural parts of that workflow got a) promoted into the language itself and b) resulted in explicit module-related tool options.

These structural information, encoded explicitly by developers in Java's module descriptors, can be used as basic building blocks when describing a modular Java project. I think of it as a "project-info.java" file -- which I don't propose to introduce (as a part of the language) -- but it helps to transport the basic idea. With assets from the "Greetings world" example 3 a fictitious project descriptor could read like:

project greet {
  version 1-ea;
  modules com.greetings,org.astro;
  main-module com.greetings;

  module com.greetings {
    main-class com.greetings.Main;
  }
}

Based on such a project descriptor Bach calls existing (and future) JDK tools in the right order with the right arguments. Nothing more, nothing less.

Since the middle of 2020, an open community has formed around the goal of making Bitcoin more intuitive and accessible. Our big project is a Bitcoin Design Guide to help both designers and developers create better Bitcoin experiences faster. We also work to promote the idea of open design, to bring more designers into the space, and to help open-source projects adopt better design processes. This presentation will provide an overview of all these efforts, where we are (early) and what the future might hold.

On October 21st 2021, the European Commission approved the new Open Source Software Strategy 2020-2023 of the Commission. We will interview Evangelos Tsavalopoulos on this.

In the interview we will ask the most important questions about this strategy.

With Kubernetes gaining popularity for performance-critical workloads such as 5G, Edge, IoT, Telco, and AI/ML, it is becoming increasingly important to meet stringent networking and resource management requirements of these use cases. Performance-critical workloads like these require topology information in order to use co-located CPU cores and devices. Despite the success of Topology Manager, aligning topology of requested resources, the current native scheduler does not select a node based on it. It's time to solve this problem! We will introduce the audience to hardware topology, the current state of Topology Manager, gaps in the current scheduling process, and prior out-of-tree solutions. We'll explain the workarounds available right now: custom schedulers, creating scheduling extensions, using node selectors, or manually assigning resources semi-automatically. All these methods have their drawbacks. Finally, we will explain how we plan to improve the native scheduler to work with Topology Manager. Attendees will learn both current workarounds, and the future of topology aware scheduling in Kubernetes.

Kubernetes has taken the world by storm attracting unconventional workloads such as HPC Edge, IoT, Telco and Comm service providers, 5G, AI/ML and NFV solutions to it. This talk would benefit users, engineers, and cluster admins deploying performance sensitive workloads on k8s. Addition of newer nodes running alongside older ones in data centers results in hardware heterogeneity. Motivated by saving physical space in the data centers, newer nodes are packed with more CPUs, enhanced hardware capabilities. Exposing to use fine grain topology information for optimised workload placement would help service providers and VNF vendors too. We’ll explain numerous challenges encountered in efficiently deploying workloads due to inability to understand the hardware topology of the underlying bare metal infrastructure and scheduling based on it. Scheduler’s lack of knowledge of resource topology can lead to unpredictable application performance, in general under-performance, and in the worst case, complete mismatch of resource requests and kubelet policies, scheduling a pod where it is destined to fail, potentially entering a failure loop. Exposing cluster level topology to the scheduler empowers it to make intelligent NUMA aware placement decisions optimizing cluster wide performance of workloads. This would benefit Telco User Group in kubernetes, kubernetes and the overall CNCF ecosystem enabling improved application performance without impacting user experience.

This presentation will go over what Nextcloud introduced over 2020.

For historical research and writing, the use of a dedicated tiling window manager and other customizable FOSS tools improves efficiency. With a bit of work, manuscript facsimiles, database query tools, and other items that a historian might need to have opened simultaneously can be sorted exactly how he/she wishes, freeing crucial time from organization for proper analysis. In this presentation, I explain how to optimize a multisource historical research workflow inside a tiling window manager with an entirely libre software toolkit.

Pulp helps you fetch, upload, organize, and distribute software packages.
With Pulp 2 approaching EOL and Pulp 3 being more stable than before, we strongly encourage you to move to Pulp 3. It might be a big deal if you have a large setup and a lot of carefully curated content and repositories.
To make it easy for you, we'd like to introduce a plugin which allows you to migrate from Pulp 2 to Pulp 3 smoothly and without recreating everything from scratch.

In this talk, we'll share:

• how we are doing the migration
• what are the benefits
• when you want to use it
• how it goes (demo)

The target audience is Pulp 2 users.

Join and discover how to build your own embedded Linux system completely from scratch. You will build your own toolchain, bootloader and kernel, that you will run on system with the new Risc-V open Instruction Set Architecture emulated by QEMU. You will also build a minimal root filesystem by yourself thanks to the BusyBox project. You will finish by controlling the system through a tiny webserver. The approach will be to provide only the files that are strictly necessary. That's all the interest of embedded Linux: you can really control and understand everything that runs on your system, and see how simple the system can be. That's much easier than trying to understand how a GNU/Linux system works from a distribution as complex as Debian!

You will also get details about what's specific to the Risc-V architecture, in particular about the various stages of the boot process. At the end of the presentation, you will leave with all the hardware (!), source code build instructions and demo binaries to reproduce everything by yourself at home, and add your own improvements. Most of the details should also be useful to people using other hardware architectures (in particular arm and arm64).

Michael Opdenacker here proposes a new version of an older presentation he made 15 years ago to discover embedded Linux, and which was for a long time one of his most downloaded presentations.

This presentation should be particularly useful for people who are new to embedded Linux and/or to Risc-V, don't have Risc-V hardware yet, and wish to test each new release of the Linux kernel and U-Boot on this new architecture, to report possible regressions and propose missing features.

Many emulators offer a CRT filter, an artist's rendition of classic video.

This presentation describes emulation of the an entire NTSC or PAL video device, to produce an engineer's rendition — starting from sync discrimination and separation, through PLLs into scan placement and via QAM to extracting colour.

In the implementation discussed work is split between CPU and GPU and a range of emulated source machines are demonstrated, including in-phase machines such as the Atari 2600, machines that routinely generate sync errors such as the ZX80, machines that generate a colour signal in software such as the Apple II, and interlaced machines such as the Acorn Electron.

Reinforcement learning learns complex processes by experimenting with its environment. In this session, you will get a glimpse into Q-Learning and Neural Networks, and how they can be implemented in JavaScript using TensorFlow.js library. As an example, we will show & discuss an implementation which solves the well-known Mountain Car problem.

Have you ever thought to yourself "It would be nice to run this Go HTTP server directly in a browser for demonstration" ? No? Well I have!

But it's not possible, right? A Go WebAssembly binary can run in browsers, but cannot serve HTTP... Or could it?

Could we run a Go WebAssembly binary into a browser's ServiceWorker, and serve HTTP from it? Well let's find out!

This presentation covers the history of various governing structures and why democracy provides superior results. It then explains that open source is a form of democracy, compared to the methods used by proprietary software producers. It covers the many benefits Postgres has enjoyed using an open development model, and how its future remains bright.

Over many years of PostgreSQL development I have collected a lot of information about setting up a development environment and assorted notes about the development process that would be worth sharing. If you are new to PostgreSQL development, this can help you get set up. If you are an experienced developer, we can compare notes.

Topics covered include:

• git setup
• shell setup
• editor setup
• tags
• documentation
• using configure and make well
• core files, backtraces
• running tests
• test coverage analysis
• profiling
• sending patches
• reviewing patches
• dealing with odd platforms
• dealing with multiple branches

Openchain is a comprehensive set of requirements allowing to cope with the open source compliance challenge. Recently it even has been accepted as ISO standard. However, compliance in todays world is not possible without tool support. To get a grip on the different tools, understand what they can do and where their limitations are, the OC tooling workgroup decided to develop a capability model. This model outlines all required capabilities to cope with the open source challenge and allows to map the functionality of tools. Thus the model can be seen as a map through the djungle of tools. In this talk, Jan will introduce the model as well as briefly outline the most relevant capabilities. Links to further resources as well as first maps will be provided.

Open Source Compliance (OSC) is not a might anymore. It is part of good manufacturing practise. Since manufacturing and software grow closer, the insight that not only the Software Bill of Materials (SBOMs) become essential for maintainability and security of software but also the legal documentation can't be seen as a once printed and never read paperwork anymore. The acceptance of CI/CD as development best practise and the ever growing amount of components used from open source stacks and their imminent dependencies prevent further manual delivery of compliance artefacts. But what is required to cope with that challenge? Where do you have to put your efforts in? Which tools are the right tools to check for your purpose? To help you answer these questions, the Capability model has been designed.
This talk introduces the motivation as well as the basic aspects of the model without going into details. Guiding thoughts and ideas will be transported as well as links for further studies will be provided. Finally the talk will conclude with a few mapping samples and an outlook in which directions the work will proceed.

Open source software powers incredible scientific and research discoveries, from images of the black hole in 2019, visualising proteins in 3D virtual reality, and open source hardware can affordably save lives during the COVID-19 pandemic. Despite this, the academic credit/metric system does not incentivise or reward activities around code sharing, instead preferring to use research papers, and citations for structured reward and promotion systems.

In this short talk, we will share the vision of the Wellcome Trust Data for Science and Health team, which is working over the next five years to incentivise the foundational tools, trust, and talent required to recognise and fund open research software sustainably.

Picture Sam, a researcher in a white coat: they spend hours in the lab with their beakers, test tubes, and agar plates. Once they’ve gathered results they think the world will want to know, they write up their conclusions, publish in a journal, and repeat. While this type of research has existed for a long time, and will continue to do so, this model doesn’t effectively acknowledge newer scenarios, where machines and mass data collection result in what is often referred to by the now-buzzword “big data” – data at a scale where it must be managed and analysed with the use of computers.

This type of research gap is often addressed by Joy, the computational researcher. Joy may identify as a coder, a researcher, an engineer, a data scientist, support staff, a lab assistant, or some other title. The main theme is that Joy writes computer code in order to make their job easier, or perhaps even to make it feasible at all. Given that this computer code feeds into and creates the end results, it is reasonable to consider it a research method, albeit a less traditional research method or output than the research paper.

In the current world, Joy is typically less supported than a more traditional academic like Sam: Fewer funding calls exist for funding code work, and ever fewer recognise or reward good open source behaviour, even though an incredible number of scientific analyses rely on open source software themselves, and even though the perils of not sharing research code could be completely wrong scientific results that don't look wrong since no-one can see inside the black-box of proprietary code. Things have gotten a little better - there are scientific journals that accept software papers, and even journals that are exclusive to open source software papers, but they're far from the norm. We still have a long way to go.

In order to make real progress, research code must be open to allow others to verify, re-use, and build upon it. This includes recognising and funding underfunded areas such as open source community management, accessibility, software maintenance, and user experience. The Wellcome Trust has dedicated £75 million GBP over the next five years towards making trustworthy data science a first-class citizen in the research ecosystem. By sharing our vision with others in the open source world we hope to encourage this attitude, meet others working towards the same goals, and meet prominent contributors to the open source research ecosystem who might be looking for funding opportunities.

WebRTC has played a vital role keeping us all connected in the last yea which has brought new developers into contact with it. Many are surprised and confused at how it works and the technical decisions that were made. This talk aims to give some historical context to those choices. Hopefully this talk will reduce the confusion experience.

By a series of accidents I was on the edge of webRTC development, before it was even a thing. I've been involved in the standardisation from early on to this day, implemented most of the APIs and met most of the people who worked on it. I'll talk about the starting point, the forks in the road, some of the mistakes made and what this project has made possible.

Topics covered: Early history... Standards groups P2P vs client server RTP - why? Signalling and SDP Encryption - who do we trust ? DataChannel - choice of protocol Codec wars API abstraction level choice(s)

This talk is entirely from my point of view, but may help listeners understand how a huge project like webRTC evolves.

Are you dying to help people new to Perl, but have no idea where to start? With guidance and support of the The Perl Foundation I’ve run a survey through January 2021 to find out who the Perl beginners are, and the type of help they feel they need whether it’s through real-time chat, mentoring, tutorials - or something we hadn’t even thought of! Based on the information we’ve got from the survey, you’re welcome to get involved in the next steps of putting together the support they need.

This talk aims to cover everything about the current state of JSON support.

First, I'll cover the newest addition, JSON_TABLE in MariaDB 10.6.

Then, I'll discuss the power of JSONPath in MariaDB and how it compares to the SQL Standard and other databases. This is technically non-news but it hasn't been discussed before.

Finally, we'll take a look at other present and missing features and see what are the biggest and lowest-hanging fruits in JSON support in MariaDB.

In the ARM world, Secure Boot is typically a BootROM feature, which allows for verification of the loaded binaries (firmware, bootloader, Linux kernel) prior executing it. The main idea is to prevent the untrusted code from running on our platform. The general approach is similar across vendors, but there is no standardization in this area.

During this talk we will review the Secure Boot features in ARM SoCs from some of the most popular vendors. Not only will we analyze the Secure Boot presence or its features, but we will also focus on the tools and documentation availability. It is a known fact that often such documentation requires a signed NDA with an SoC vendor, which makes it difficult to use by regular users.

chezmoi helps you manage your personal configuration files (dotfiles) across multiple diverse machines. A single public branch in a single git repo serves as the source of truth, with machine-to-machine differences and integration with your password manager handled with templates. With chezmoi you can set up your personal environment on a new machine with just two short commands, with minimal dependencies. It runs on Linux, macOS, FreeBSD, OpenBSD, and even more esoteric operating systems like Termux and Windows.

In this lightning talk we'll dive straight in to getting started with chezmoi, take a quick peek under the hood to see is architecture and technical choices, and compare it with other dotfile managers.

In this talk we give an update on the Unikraft Linux Foundation open source project, a fully modular and librarized unikernel that aims to provide outstanding performance while making it easy to port off-the-shelf applications into unikernels. In particular, we will go into details how Unikraft (1) fully modularizes OS primitives so that it is easy to customize the unikernel and include only relevant components, (2) exposes a set of composable, performance-oriented APIs in order to make it easy for developers to obtain high performance and (3) aims for POSIX compatibility, already supporting over 130+ syscalls. In addition, there are ongoing efforts to integrate Unikraft into popular frameworks such as Kubernetes and Prometheus in order to finally bring the promise of unikernels to the mainstream. Our recent evaluation using off-the-shelf popular applications such as Nginx, SQLite, and Redis shows that running such applications on Unikraft results in a 30%-50% performance improvement compared to Linux guests. Unikraft images for these apps are around 1MB, require less than 10MB of RAM to run, and boot in around 1ms on top of the VMM time (total boot time 2ms-70ms). During the talk we will show a brief demo. Unikraft is Xen Project incubator project.

During that presentation I will run a quick demo of the OSFCI infrastructure which is developed by HPE to validate and build Open Source Firmware stack on Proliant server. I will introduce an overview at how the code works, and how to get involve, and make scale the platform. This project is available on github. https://github.com/hewlettpackard/osfci

OSFCI is an interactive testing platform for Open Source Firmware. From a single web browser, a firmware developer can recompile ROM at BMC and System level, load them to a real system, and execute an interactive session to validate firmware behavior on real hardware. The goal of this infrastructure is to provide end to end validation automation for firmware development, easing adoption for open source firmware at scale.

Go programmers now have access to an entire world of Bluetooth devices, the most popular Wireless Personal Area Network (WPAN) standard ever created, all using our favorite programming language, thanks to the aptly named "Go Bluetooth" (https://tinygo.org/bluetooth).

Developers can write code to control Bluetooth Low Energy devices from standard Go programs running on desktop operating systems.

In addition, developers can create Bluetooth Low Energy peripheral devices running bare-metal on chips made by Nordic Semiconductor, by using "Go Bluetooth" with TinyGo.

This means you can write the code for both sides of your Bluetooth Low Energy wireless application all using Go.

In this talk I will explain the concepts and show code by programming several live objects.

The time has come for Kuma — the platform that powered MDN Web Docs — to evolve. For quite some time now, the MDN developer team has been planning a radical platform change. That change has now landed. In short, we have moved away from our wiki model where the content was stored in a centralized SQL database, to a decentralized pull request model via Github. Our tech stack has also radically changed, paving the way for faster future development, ease of maintenance, and opening up the platform for contribution from our community. During this talk, I will share the history of the project, talk about our recent achievements, demonstrate how to contribute to both the MDN Web Docs content and the underlying platform, and take a peek at what the future looks like for MDN Web Docs.

Kubernetes graduated Container Storage Interface (CSI) to GA status in v1.13. Since CSI’s origin, it has evolved to support a large number of vendors and storage formats. It has brought the industry together in consensus about the best practices in storage. However, CSI’s major limitation is that it only supports Block and File storage. The rapid growth of Object storage means that a growing share of the ecosystem is currently using ad-hoc solutions to leverage this new technology. Object storage is a fundamentally different paradigm where data is accessed over the network rather than locally. It allows applications to remain stateless while offloading state into a black box over the network. Object storage is the key enabler for cloud migration. This paradigm, however, does not have a standard mechanism for consumption in Kubernetes. COSI fundamentally exists to enable the natural consumption of object storage with Kubernetes.

In this talk, we discuss our efforts in bringing object storage into the forefront of Kubernetes and introduce the Container Object Storage Interface (COSI) and cover: - Why COSI is needed for Kubernetes - Best practices for using COSI - Designing apps to leverage COSI - The COSI architecture, and how to contribute to the project.

Unlike GPU cards, quantum acceleration is unlikely to be available as a personal computer in the near future. Right now all the known quantum computers are owned by major players. The lack of availability of quantum computers makes it beneficial to centralize the power of quantum computers, using a SaaS model to democratize access to them, therefore making the cloud a suitable home for quantum computing.

The first part of the session introduces an open-source co-processor model where classical computers can offload specialized tasks that are better suited to quantum computers thus lowering the onramp to incorporating quantum computing into applications today.

The next part of the sessions demonstrate how to build a co-processor model on the cloud using two community operators that provide quantum acceleration by leveraging Qiskit, an open-source SDK for developing quantum circuits, classical components powered by Red Hat OpenShift and IBM Quantum Experience as the quantum backend

The session concludes with a small demonstration of how to run a quantum circuit on the cloud using the co-processor model.

This talk will demo the setup and features of an on-premise software for storing, mirroring, and distributing Ansible Collection and Role content. This is analogous to an on-premise version of galaxy.ansible.com. To get up and running quickly, we’ll be using a pre-built container with pulp_ansible and galaxy_ng.

A single container is all that is needed for setup. Once setup, I will demonstrate:

• Creating one or more repositories to store Collections and Roles
• Installing Role and Collection content using the ansible-galaxy CLI client from these repositories
• Synchronizing Collections and Roles from galaxy.ansible.com
• Uploading Collection content via ansible-galaxy CLI
• Copying Collections and Roles between multiple repositories, simulating dev -> staging -> production environments
• Perform these operations using a great UI, whenever possible, and APIs otherwise

Working with OpenOffice in the documentation effort is rewarding and benefits the community! Join me to discuss documentation!

The transcript for this presentation is attached.

The presentation editable designs in Draw - see link for template.

Step 1. Draw edits for design

1. Download template
2. Open in Openoffice.org Draaw
3. Edit

Step 2. Create Presentation

1.Copy page from Draw 2.Paste slide to Impress. 3. Place image of presenter in Master slide 4. Review impress slides with master image 5. Start Presentation mode 6. Begin recording session

Very little editing at all with this method.

Note: Original designs using venngage. In accordance with the Terms of Service, output PDF, import PDF to Draw for editable free content. GFDL.

https://templates.openoffice.org/en/template/fosdem-presentation-draw-template

In this session I'll talk about the brief history of Drupal & the Drupal interface, how it has evolved and why this redesign is an important step for the future of Drupal. As it's important to being inclusive and we treat this as a key value in the Drupal community we made inclusivity & accessibility the main priority.

I will dive into the Design System, the principles behind it and the new interfaces which are based off this Design System:

Claro The new, upcoming default admin experience.

Gin The so-called "Future UI" – which started as a pure vision and is now available as a contrib theme which you can use today.

OpenNebula has recently incorporated a new supported hypervisor: Firecracker. This next generation virtualization technology was launched by AWS in late 2018 and is designed for secure multi-tenant container-based services. This integration provides an innovative solution to the classic dilemma between using containers—lighter but with weaker security—or Virtual Machines—with strong security but high overhead.

Firecracker is an open source technology that makes use of KVM to launch lightweight Virtual Machines—called micro-VMs—for enhanced security, workload isolation, and resource efficiency. It is widely used by AWS as part of their Fargate and Lambda services. Firecracker opens up a whole new world of possibilities as the foundation for serverless offerings that need to deploy containerized critical applications nearly instantly while keeping them in isolation.

OpenNebula is a simple, yet robust, open source platform for building Enterprise Clouds and managing Data Center virtualization. Its integration with public cloud providers offers additional flexibility in creating True Hybrid and Edge infrastructures. By incorporating Firecracker, OpenNebula now provides users with a powerful solution for serverless computing and an alternative, native model for secure container orchestration.

In this talk we will explain the technical details of this integration and will show a live demo on how to easily deploy and orchestrate a composition of Docker Hub images running as Firecracker microVMs on a distributed bare-metal Edge infrastructure.

Holochain is an open-source development framework and distributed P2P networking protocol. It allows you to create truly serverless applications with high levels of security, reliability, and performance. Every user runs the application on their own device, creates and stores their own data, and talks directly to other users.

In this talk I introduce Holochain (a framework for building peer-to-peer applications), explain what problems it's trying to solve, show how it tries to solve them differently from blockchain and other decentralized protocols, and drop some juicy details about what you as a dev need to know if you want to start developing on it. Fun whiteboard scribbles explain the concepts along the way.

Interesting links

Holochain https://holochain.org Holochain Dev Docs https://developer.holochain.org GitHub https://github.com/holochain Holo Host https://holo.host WebAssembly https://webassembly.org/ Rust https://www.rust-lang.org/ WebSocket https://en.wikipedia.org/wiki/WebSocket

So you want to monitor a large-scale network-- where do you start? This talk will give you some practical tips in strategizing your network monitoring to avoid future problems, detect those you didn’t know are causing performance issues and save your time in configuration. You’ll learn practical tips, summarized into 3 simple rules, coming from the speaker’s 20+ years of experience as a network specialist. Whether you're starting your monitoring from scratch or improving an existing setup, these tips will be useful for you to have a holistic network monitoring.

Along with the practical tips, the speaker will show some demos on how you can apply them using Checkmk, an open source IT monitoring software. We will discuss best practices to take advantage of rule-based monitoring in discovering all your network interfaces. After learning the fundamentals, we'll discuss how you can take it further with network flow monitoring using ntopng. This will help you troubleshoot network issues through in-depth network performance monitoring and network flow analyses.

By the end of the talk, you’ll get to learn a holistic approach to network monitoring; saving your organization lots of time, as well as budget for hiring external consultants.

In this talk we present the experience of the software produced, as part of the research activities, at the French Gaspard-Monge Computer Science laboratory (Laboratoire d'informatique Gaspard-Monge or LIGM in French).

The LIGM has an important production of research software with 66 software items identified for the period 2013-18, where 50 have been disseminated as FOSS. Since 2006, the Lab has worked in order to improve the dissemination and the visibility conditions of this research production [1], which includes the adoption of policies and the production and maintenance of a catalogue.

In this context, one of the first issues we had to deal with was the concept of the Lab's software, in order to answer the questions of the researchers. The second concept was the identification or reference (or citation form) of such objects.

The concept of "Logiciel d'un laboratoire" [1,2] initially proposed in 2006 has since then evolved to become research software ("Logiciel de la recherche") and it is a central concept in order to propose services and infrastructures to deal with this production in the current Open Science global context evolution [3,4], where the goals are to make it visible, accessible, reusable. It is also a central concept in order to propose research evaluation procedures related to this scientific output [5].

In this talk we will detail the evolution of this work since 2006 and we will present the current state of the art.

[1] T. Gomez-Diaz (2013) Patrimoine logiciel des laboratoires https://hal.archives-ouvertes.fr/cel-01804283

[2] T. Gomez-Diaz (2015) Article vs. Logiciel : questions juridiques et de politique scientifique dans la production de logiciels http://www.societe-informatique-de-france.fr/wp-content/uploads/2015/04/1024-5-gomez-diaz.pdf

[3] T. Gomez-Diaz, T. Recio (2020) A policy and legal Open Science framework: a proposal https://zenodo.org/record/4075106

[4] T. Gomez-Diaz, T. Recio (2021) Open comments on the Task Force SIRS report: Scholarly Infrastructures for Research Software (EOSC Executive Board, EOSCArchitecture). Research Ideas and Outcomes 7: e63872. https://doi.org/10.3897/rio.7.e63872

[5] T. Gomez-Diaz, T. Recio (2019) On the evaluation of research software: the CDUR procedure https://doi.org/10.12688/f1000research.19994.2

The Call API is a management front-end for OpenSIPS 3.1+ SIP servers, aiming to abstract the SIP layer and to simplify the management of more advanced SIP call flows. Moreover, it enables event-driven architectures by providing real-time events on the handled call scenarios.

The OpenSIPS 3.1 major release is not just about one piece of software, rather an entire ecosystem! After the recently introduced opensips-cli console environment, aimed at improving the interaction with an OpenSIPS 3.0+ server, we are proud to introduce the Call API -- a responsive, fully asynchronous, high-throughput API, built to abstract all the complexity behind the more arcane SIP calling scenarios (think click-to-dial scenarios, blind transfers, attended transfers, etc.) into intuitive, easy-to-invoke JSON-RPC commands.

The first half of the presentation will include an architectural overview of the API. You will learn how to interact with it, how the API further interacts with the OpenSIPS backend, as well as some best practices on writing API clients in your favourite programming language.

In the second half, you will learn about the specific SIP scenarios exposed by the API, how they work behind the curtains and what kind of services you can build on top of them.

Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?

In this session I'd like to present the benefits of Test-Driven Development (TDD), explaing how it works and what the benefits are of using it. We will see in a more detailed approach this way of developing software, where our software is always built guided by tests.

We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with a Java code example.

At the end of the session, I hope attendees will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code 😉

The lack of accessible quality healthcare is one of the biggest problems in Africa and other developing countries. This is not only due to the unavailability of resources, but also to the absence of a structured formative process for the design and management of healthcare facilities. This situation strongly contributes to deepening inequalities in access to quality healthcare. Through an Open Society Foundations funded project, the Mboalab aims to remedy these inequalities by building Open-Source devices for medical labs. Local manufacturing can address the infrastructural barriers that prevent imported or donated equipment from being properly used, and can facilitate the diffusion of innovation into healthcare practice. This project is part of the large MboaLab mission to contribute to the Common good and catalyze sustainable local development through Open Science.

Open science is the best and fair approach to support local manufacturing. That is why the crux of our approach is the use of “open source hardware”, where designs for easily replicated, high quality diagnostic tools are shared with the potential to transform medical devices through the use of digital fabrication and inexpensive, well-engineered parts from mass-produced consumer goods. During FOSDEM, we will present the different facets of our project: 1) the set of prototypes of high quality and inexpensive open-source devices we are going to build; 2) the capacity and capability building dimension of the project, enabling the empowerment of young cameroonians; 3) Expectations of the project.

Jakarta EE 9 lowers the barriers of entry, ease migration, and lays a foundation for future innovation.

Jakarta EE 9 is out! This is the second release of Jakarta EE since the transition from the Java Community Process (JCP) to the Eclipse Foundation. In this session, I will go through what Jakarta EE 9 brings to the table and how this release lowers the barriers of entry, eases migration, and lays the foundation for a platform for future innovation.

We will also look ahead to what future releases may bring. The session includes a demo including converting from the javax. to jakarta. namespace as well as looking at available implementations.

I explore how I have eliminated nearly all void pointer casting from the libwayland/wlroots APIs in my Zig bindings without introducing overhead or significantly increasing complexity. This will include a demonstration of how Zig's compile time code execution features make such a task quite straightforward. I will then discuss the experience of updating river, my wayland compositor, to use the bindings over the auto-generated bindings provided by Zig's @cImport() feature.

Assessing whether a system is safe, requires understanding the system sufficiently. If the system depends on Linux, it is important to understand Linux within that system context and how Linux is used in that system. The challenge is selecting Linux components and features that can be evaluated for safety and identifying gaps that exist where more work is needed to evaluate safety sufficiently.

The ELISA project has taken on the challenge to make it easier for companies to build and certify Linux-based safety-critical applications. This talk will be given by Shuah Khan from the Linux Foundation to give an overview of the ELISA project and its technical strategy.

MySQL performance can be improved by tuning queries, server options, and hardware. Traditionally it was an area of responsibility of three different roles: Development, DBA, and System Administrators. Now DevOps handle these all. But there is a gap. Knowledge, gained by MySQL DBAs after years or focus on a single product is hard to gain when you focus on more than one. This is why Sveta Smirnova (Percona, Support Team) is doing this session. She will show minimal, but the most effective, set of options that will improve your MySQL performance. For illustrations, she will use real user stories from her Support experience.

An overview and discussion regarding the openSUSE Project's latest rolling-release distribution, MicroOS. The session will detail how concerns regarding the stability of rolling releases are addressed by narrowing the scope of OS, and using technologies like (Atomic) Transactional Updates and automated health checking to guarantee the system keeps working. The session will cover how MicroOS is developed, and the broad range of suitable use cases, from Container server workloads, to Raspberry Pi's and Desktops including real-world examples from the community.

Open Compliance Reference Tooling in action. The talk will show the most important building blocks of a working automated Open Source Management pipeline based on Open Source Tools as well as the necessary processes and workflows around the tooling to leverage open component metadata from the community.

Based on the OSS Review Toolkit as orchestrator, several Open Source tools (like ScanCode, FOSSology, ...) as well as Open Standards like SPDX and open data-sources like Clearly-Defined may be used to provide an automated end-to-end Open Source Compliance pipeline. From the process side, there are different ways to implement this in different organizational contexts. The talk will provide one reference process for continuous integration and continuous deployment. A short demo will be given to illustrate the advantages and challenges of the approach. As everything is based on Open Source, this approach shall help to support the Open Chain idea to provide a state of the art reference tooling for everyone in the supply chain and thus raise the overall Open Source Management maturity.

In 2020 we saw a huge spike in interest for RTC. Developers worked quickly to build new tools with the challenge of a socially distanced world. Go has really started to make strides in the RTC world with Pion. Easy deploy, great performance, memory safety and ability to prototype helped it take on C/C++.

This talk shows you some basics on WebRTC, then how to use Pion and what you can build with it

• What does WebRTC give us?

• What technical real world limitations does WebRTC need to overcome to give us that?

• WebRTC broken down to 4 parts

  • Signaling
  • Connectivity
  • Encryption
  • Media/Data

• Pion

  • Connecting
  • Using DataChannels
  • Using Media

Open Source Showcase (https://github.com/pion/awesome-pion)

• All from https://github.com/pion/awesome-pion
• https://twitter.com/_pion/status/1273910045244133376
• https://github.com/saljam/webwormhole
• https://github.com/mxseba/rtc-ssh
• https://github.com/nurdism/neko
• https://github.com/maxmcd/webtty
• https://github.com/giongto35/cloud-morph
• https://github.com/s4y/space
• https://cedricverst.medium.com/streaming-surveillance-cameras-using-webrtc-403ef36795f8

Infrastructure as Code (IaC) is an approach that takes proven coding techniques used by software systems and extends it to infrastructure. It is one of the key DevOps practices that enable teams to deliver infrastructure, and the software running on it, rapidly and reliably, at scale.

In this presentation, we will look at Principles, Patterns, and Practices for Effective Infrastructure as Code that have helped me and the teams I have worked with over the years. We will look at anecdotes about deploying & operating infrastructure and applications in production.

Infrastructure as Code (IaC) is an approach that takes proven coding techniques used by software systems and extends it to infrastructure. It is one of the key DevOps practices that enable teams to deliver infrastructure, and the software running on it, rapidly and reliably, at scale.

In this presentation, we will look at Principles, Patterns, and Practices for Effective Infrastructure as Code that have helped me and the teams I have worked with over the years. We will look at anecdotes about deploying & operating infrastructure and applications in production.

Emerging applications like artificial intelligence and autonomous car require high security-assurance, which stimulates the wide-spread deployment of trusted execution environment (TEE). However, prior enclave systems are far from the ideal for three reasons. 1) Scalability: only support limited secure memory or limited number of instances; 2) Performance: not well-fit the requirements of high-performance application, e.g., poor secure communication performance; 3) Security: many still have security flaws, e.g., suffering cache-based side channels attacks.

Penglai-Enclave is proposed to overcome these challenges. The Penglai open-source project aims to build a scalable and efficient TEE system based on RISC-V, which is made powerful through hardware-assisted scalable physical memory isolation extensions. Our evaluations show that Penglai can achieve more than 1,000 concurrently running instances even in a resource-restricted device. We also have supported libraries like ARM PSA on Penglai to ease the development of trusted applications, and applied formal methods to validate its software TCB.

Free and open source software is made up of a truly global community of tinkerers, collaborators and innovators. In this conversation, Deb Nicholson and Hong Phuc Dang will look at the global state of open source policy and talk about why no particular country -- especially the US -- should be centered. So, let's make sure the conversation about the future of open source is a truly global one!

Sure, lots of tech came from the US; Microsoft, Apple, Google, Facebook, Amazon but a large proportion of the story of free and open source software didn't happen in the US. In fact, most of the exciting parts of the work to encourage people to adopt, build and adapt open source are happening in other places. In this conversation, Deb Nicholson and Hong Phuc Dang will look at the global state of open source policy and talk about why no particular country -- especially the US -- should be centered. They'll cover:

* Public code strategies and adoption of open source tools in different jurisdictions
* Policy initiatives that foster free and open source software production
* Local FOSS adoption blueprints that could be replicated around the world

Open source is a global community of tinkerers, collaborators and innovators. It's time to share the spotlight more equitably. Solutions for small cities, or minority language groups or vulnerable populations could come from anywhere and be applied around the world. The discussions around public code and adoption aren't even happening in the US yet, and code without hearty adoption isn't enough. So, let's make sure the conversation about the future of open source is a truly global one!

Query optimizer is one of the key components which determines DBMS performance under OLAP workload. Nevertheless, it was shown that query optimizer often fails to find a good execution plan because of incorrect cardinality estimations. The perspective approach to improve cardinality estimation quality is adaptive query optimization. In contrast with classical approaches, which rely on the precomputed histograms, it utilizes the execution statistics of the previously executed queries to refine cardinality estimations. However, the original AQO uses a modification of kNN machine learning method, which implies a number of limitations on the AQO applicability. In the current lecture we will make an introduction to the kNN-based AQO. Afterwards, we will present you our novel neural network-based AQO which can potentially overcome the limitations of the kNN-based AQO, and will demonstrate the first experimental results.

GFXprim is a modular and minimal graphic and widget library written in plain C. The library is very close to fulfilling its goals hence it's time to present it to a wider audience. Since this is supposed to be quick lightning talk I would like to give rough overview of the library, it's modules and implemented functionality.

RetroArch is a free, open-source and cross-platform frontend for emulators, game engines, video games, media players and other applications. The libretro API is designed to be fast, lightweight, portable, and without dependencies. Due to the number of systems and games it can play under a single user interface, RetroArch has grown immensely over the years, and has been well adopted by the emulation scene.

Since its inception as SSNES and libsnes, libretro has grown much beyond its humble upbringings. libretro and RetroArch provide a way to connect different applications, emulators and game engines together in a single application.

libretro has a unique mission design in turning the way applications are built on its head, by enabling the modularization of software. Instead of merely thinking in terms of a standalone application, software is redesigned and re-engineered to become a pluggable module that interfaces through a common API. Standalone applications implement this API to gain access to this module. Our belief is that by following this model, applications can be more easily updated and extended, since there is a clear separation between application and core domain.

In this session, we will cover:

• What libretro is all about and its software model
• Interesting frontends and hardware you can use
• libretro cores and how to implement your own
• The ecosystem surrounding RetroArch
• What's next for the project

Join Rob Loach, libretro maintainer, as he discusses how you can fully leverage the libretro API to bring modularized applications and systems together.

Software Heritage is a long term, non profit, multistakeholder initiative with the ambitious goal to collect, preserve and share all source code publicly available, protecting our Software Commons, in collaboration with UNESCO. In this presentation we will share recent developments in the Software Heritage archive that make it the ideal platform for archiving, referencing and citing research software: it's a stepping stone for reproducibility and for raising awareness about the importance of software in research.

With the advancement of open source firmware projects, we need a reliable quality assurance process to automate the firmware level testing. In this talk I'd like to show how we build up a ecosystem for open-source firmware testing and show by example how we integrated one project into that ecosystem. This talk aims to give a status update what has been show on the OSFC2020, and also encourage people to get involved and participate in open-source firmware testing. All code shown is open-source and available by the time of FOSDEM'21.

Igalia has been developing a new open source Mesa driver for the Raspberry Pi 4 since December 2019. This talk will discuss the development story and current status of the driver, provide a high level overview of the major design elements, discuss some of the challenges we found in bringing specific aspects of Vulkan 1.0 to the V3D GPU platform and finally, talk about future plans and how to contribute to the on-going development effort.

Nowadays, lots of users are concerned about the safety of their confidential data when it comes to online collaboration. And their concerns are fully justified.

So we at ONLYOFFICE, an open-source project with the focus on advanced and secure document processing, do our best to provide a comprehensive level of security for online doc editing and collaboration.

With GDPR compliant ONLYOFFICE Docs, you get a wide range of security tools and services to protect yourself from unauthorized access, data leaks, or insider actions. Self-hosted ONLYOFFICE can be installed on your own private server, so all your data always stays ‘in-house.’ The server level of data protection is implemented, among other things, with JSON Web Token and configurable cache lifetime. Important is, that no user data is stored on the ONLYOFFICE server. Besides, there are additional security features such as restriction on copying, downloading and printing, watermarking, flexible document permissions, etc.

The same applies to the integration of ONLYOFFICE Docs with other open-source services and platforms so that users of the combined solutions also get secure document editing and co-authoring.

To make your experience even more secure, last year we implemented:

• Custom filter access permission that allows hiding the data you don’t want to show before sharing your spreadsheet. In other words, users won’t be able to change the filter you’ve applied before sharing your spreadsheet and will be able to work only with the specified fields.

• Storage encryption so that you can protect data at rest against breaches. If the storage encryption option is enabled, all the files stored in your ONLYOFFICE will be encrypted using the Advanced Encryption Standard, symmetric block cipher, also known as Rijndael, that encrypt data blocks of 128 bits using symmetric keys of 256 bits.

• The first version of ONLYOFFICE Private Rooms, protected workplaces where every symbol you type is encrypted using the unbreakable AES-256 algorithm, even if you are co-editing documents with your teammates in real-time. Files that are created, stored and shared within a Private Room never leave the directory and cannot be copied, re-distributed, or decrypted. Document encryption and decryption is performed strictly on the user’s machine end-to-end.

Besides, we are now working on multi-functional secure forms for building any document template and secure form filling when your co-author is not permitted to see some parts of the doc.

BabiaXR is a set of front-end FOSS modules for VR data visualization for the browser. BabiaXR is composed of different modules (for querying, filtering, and representing data) 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 WebXR and regular web front-end programming.

There are plenty of tools that can analyze data in many ways, most of them are composed of a full-stack app, and the well-known front-end libraries limit the visualization on the 2D and screen environment, just a few of them try to visualize this data in the browser integrating other technologies/environments like webXR. This is the goal of BabiaXR, a set of front-end modules for 3D and VR (virtual reality) data analysis. The visualization part of BabiaXR is based on A-Frame and Threejs, providing a collection of components for querying data, filtering data, and creating different kinds of visualizations, all of them developed using just front-end technology. Among the visualizations, there are common ones like bar charts, pie charts, bubbles chart, but now we are moving beyond that, exploring new ways of show data in 3D/VR. 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 WebXR and A-Frame with different visualizations, and how simple is to develop this kind of module using just JavaScript and other front-end libraries. 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.

Registration (User Location) is an important part of a SIP infrastructure, eg: where to send a call for a particular user. During this presentation we'll learn how to scale FreeSWITCH capabilities so to handle high volume / high frequency transactions by having a mid-registrar absorbing the most transactions and only bother FreeSWITCH with the bare minimum info it needs (is the user reachable, and where). Multiple parallel calls can be "forked" if the user is registered as present at various devices (eg: deskphone and smartphone app), push notifications can be sent to "wake up" the user's app. We'll use OpenSIPS as an example of mid-registrar, but the same concepts and techniques can be implemented by any open source SIP proxy, like Kamailio, Repro, etc

In this talk we explore two programming models for GPU accelerated computing in a Fortran application: OpenMP with target directives and CUDA. We use an example application Riemann problem, a common problem in fluid dynamics, as our testing ground. This example application is implemented in GenASiS, a code being developed for astrophysics simulations. While OpenMP and CUDA are supported on the Summit supercomputer, its successor, an exascale supercomputer Frontier, will support OpenMP and translate CUDA-like models via HIP. In this work, we study and describe the differences and trade-offs between these programming models in terms of efforts and performance. Our hope is to provide insights on productivity and portability issues within these programming models.

Most of the free software projects I know do little to none research with their users. Well: the vast majority do absolutely none, and very few do a teensy little bit, most of the time with the most vocal members of their user base. Why is that? Why is free software afraid of user research?

This presentation will propose a classification of free software types based on their ideas and attitudes towards user research. The classification is really just a joke, but I hope it will help me debunk some of the misunderstandings and myths that surround user research in free software circles. I will also try to explain what user research is actually about, how it can help your free software project, and give you some advice on how to get started with it.

Panel discussion and an extended Q&A session on the state of microkernel-based operating systems in 2021 and related topics. The panelists (in order of acceptance):

• Martin Decky (HelenOS, Huawei)
• Jakub Jermar (Kernkonzept, HelenOS)
• Norman Feske (Genode Labs)
• Julian Stecklina (Cyberus)
• Udo Steinberg (BedRock Systems)
• Matthias Lange (Kernkonzept)
• Gernot Heiser (seL4)

The discussion will smoothly evolve into the traditional and less formal "microkernel dinner". Please bring your own food and beverages.

A proposal to support AWS SQS API natively in Ceph RGW, for advanced Serverless computing use cases.

Bucket notification has become widespread in many applications including AI/ML and Edge Computing. We have demonstrated that Ceph RGW bucket notifications trigger Serverless functions including Knative and AWS Lambda. Such workflows can be characterized as event push and event driven.

We’ve identified yet another workflow that allows Serverless computing frameworks to be more preemptive in auto scaling. The workflow is based on the event queue polling model, the opposite of event push, that allows Serverless computing frameworks, such as KEDA, to preemptively scale the functions based on the queue length. Such workflow is more advantageous and lightweighted in dealing with highly bursty event traffic and reducing Serverless function cold start overhead.

In order to support this workflow, we propose a new set of message queue APIs, modeled after AWS SQS, for Ceph RGW. In this talk, we’ll present the overview and planning of this technology to the community.

Cloud computing has revolutionized the way we think about IT infrastructure: Another web server? More database capacity? Resources for your artificial intelligence use case? Just spin-up another instance and you are good to go. While most cloud images (e.g., AMIs on Amazon EC2) are meant to run a single service (e.g., nginx), for convenience these tend to be built on top of general-purpose OSes and full distributions, often resulting in GB-sized images that sometimes only need to perform a simple task such as serving static web pages. One of the main contributing factors to this status quo is the myriad kernel inter-dependencies, rendering debloating of a Linux kernel image far from trivial. In this talk we will show results from a proof-of-concept deployment on Amazon EC2 using Unikraft, a fully modular library OS that makes it easy to remove unneeded components, and to optimize the remaining ones. On EC2, a Unikraft nginx image is able to outperform an nginx Debian image by 2x in terms of requests/sec when serving static content, all the while consuming 1/6 of the memory (we will show a brief Unikraft demo). Unikraft is an open source Xen Project incubator under the auspices of the Linux Foundation.

We sometimes hear statements like "Mozilla is one of the oldest Free & Open Source projects in existence today, with more than 20 years of history - and still going strong". But where exactly did this project come from? What happened early in its history? What did the project go through to come to where it is today? This talk will try to answer those questions and compress multiple decades into less than an hour - or at least give an overview of the big-picture events this project lived through. As the audience may be more familiar with recent than earlier years, more emphasis will be put on times when the project was still young - for some things even reaching back to times before the speaker joined the community in 1999. After attending this talk, you will hopefully have a better understanding of the background of the Mozilla project and how it has helped shaping the web for the better, something that will hopefully continue into the future.

The roots of Mozilla go back almost to the beginning of the web itself. The first broadly used web browser in university circles was NCSA Mosaic - the co-writer of that piece of software created a commercial variant back in 1993, going under the commercial name of "Netscape" when it was released and became the first major web browser in Internet history. But its code name, right from the start, was "Mozilla". When Netscape open-sourced its code in March of 1998, that code name became the public name of the open source project, and over the years, Mozilla attracted a large community of developers, localizers, and more. A non-profit Mozilla Foundation was created, with a "corporation" subsidiary for tax reasons, and a huge list of projects and products have been associated with Mozilla over its more than 20 years of history. The most well-known is of course the Firefox web browser, which has been one of the most-used open-source products for many years - hundreds of thousands of people browse the web with Mozilla Firefox even nowadays. After decades, this project and community is still going strong - hopefully continuing to do so in the future.

The speaker has been with this community for over 20 years himself and the talk will give you and overview of the origin, past, and present of this interesting project.

How to use Vagrant to automate the creation of development machines running MariaDB.

Usually a devops team takes care of creating development machines that the developers will use in their daily work. Vagrant makes this task very easy. Though, there are some good practices that will increase development/production parity and will help developers to optimise their code.

[NO PRERECORDED VIDEO, WILL RUN AS BOF] An overview about the current status of the web resources of the Apache OpenOffice Project. This will include how they are managed within the Apache Software Foundation Infrastructure along with helpful third parties.

It brings the concept of roles that help classify your automation tasks/playbooks and group them by purpose.

But :

When should we use Ansible roles? How to create and test Ansible roles? What tools do we have to ease the process? How can we apply best practices of software development (TDD) to ensure your roles are doing what they are intended to? This talk will introduce you to Ansible Roles testing will Ansible Molecule; a tool used to drive ansible roles testing. Moreover, we will try to apply the Test Driven Development (TDD) process to test our roles.

So, come and see us, to learn more about Ansible and Ansible Roles Testing.

Ansible is the simplest way to automate apps and IT infrastructure. Application Deployment + Configuration Management + Continuous Delivery.

It brings the concept of roles that help classify your automation tasks/playbooks and group them by purpose.

But :

When should we use Ansible roles? How to create and test Ansible roles? What tools do we have to ease the process? How can we apply best practices of software development (TDD) to ensure your roles are doing what they are intended to? This talk will introduce you to Ansible Roles testing will Ansible Molecule; a tool used to drive ansible roles testing. Moreover, we will try to apply the Test Driven Development (TDD) process to test our roles.

So, come and see us, to learn more about Ansible and Ansible Roles Testing.

Musicians, producers and composers use digital audio workstations (DAW) in daily work. You've probably seen beautiful photos from recording studios: a sound engineer is sitting in front of several monitors with multi track recording application windows and dialogs?! This is the DAW.

But what's about to run DAS (Digital Audio Server): the server instance with DAW benefits + multi client access from web, compatibility with popular cloud services, FOSS and Raku-driven backend.

In this lecture we will consider DAS backend as a JRP pipeline — JUCE + RAKU + PHEIX, focus on each component and demonstrate Raku as the tool for unusual daily programming tasks.

When we talk about sound processing on the remote server or cloud, we assume the set of various web audio services: AI composers, recognizers (stylistic classifiers, plagiarism scanners, audio content reviewers), co-creativity, etc... Each of these services bases on headless processing and mixing audio backend. Actually this is a Digital Audio Server (similar to a DAW), providing multitrack recording, mixing and processing in real time via API.

The fundamental differences between DAS and DAW are: Linux platform, no GUI and the TCP/IP stack as the only data transport. In this paradigm we can define DAS software as Linux + headless audio backend.

Frontend provides visualization of processes on the backend, works in the context of web browser on client workstation and interacts with the backend via, for example, REST-API.

This talk defines the DAS headless audio backend as a JRP pipeline —  JUCE + RAKU + PHEIX.

The JUCE framework has the large set of the tools and features required for audio processing. It is one of the most well-documented, actively evolved and powerful audio frameworks with the Linux support.

The PHEIX content management system is used to interact with the frontend. It is currently the only CMS with Ethereum Blockchain native support. For the audio industry, in terms of copyright protection, this is definitely a must-have solution — since all metadata passing through the Digital Audio Server can be stored in a distributed ledger (both private and public, for example, the Görli network) and used for copyright disputes in future.

PHEIX is written in the RAKU language: the most promising and at the same time underrated programming language. In JRP concept — RAKU is the glue for the DAS backend components on the one hand, and the high-level adapter for the JUCE application on the other.

In the practical part of this lecture, we will consider the sample web audio service for frequency analysis and audio content visualization. The example demonstrates methods for creating and deploying a JUCE application as a shared library on a Linux platform. We will pass the step-by-step dev process of the RAKU application-level module with a JUCE bindings, make an integration into PHEIX and try it all from the simple frontend.

This lecture primarily aimed at architects and programmers of web audio services, JUCE community members with Linux background, and RAKU enthusiasts who are involved in digital audio processing.

Jakarta EE 8 has been delivered and Jakarta EE 9 is well on the way. This is a perfect time to begin exploring the horizons of Jakarta EE 10 and how you can help make it reality.

We will guide you on how to begin contributing towards Jakarta EE 10. We will cover ways of contributing, what paperwork is needed as well as the likely possibilities for Jakarta EE 10 including high level themes, platform level changes and some detailed features. Some technologies that might change include Jakarta Security, Concurrency, Messaging, Persistence, REST, Batch and Faces. New APIs that could be added include Jakarta NoSQL, MVC and Configuration. We will talk about non-specification projects such as the Tutorial and Samples.

We will also discuss what might be after Jakarta EE 10. Bring your thinking caps!

Permissionless blockchain environments necessitate the use of a fast and attack-resilient message propagation protocol for Block and Transaction messages to keep nodes synchronised and avoid forks. We present GossipSub, a gossip-based pubsub protocol, which, in contrast to past pubsub protocols, incorporates resilience against a wide spectrum of attacks.

Firstly, GossipSub's mesh construction implements an eager push model keeps the fan-out of the pubsub delivery low and balances excessive bandwidth consumption and fast message propagation throughout the mesh. Secondly, through gossip dissemination, GossipSub realises a lazy-pull model to reach nodes far-away or outside the mesh. Thirdly, through constant observation, nodes maintain a score profile for the peers they are connected to, allowing them to choose the most well-behaved nodes to include in the mesh. Finally, and most importantly, a number of tailor-made mitigation strategies designed specifically for these three components make GossipSub resilient against the most challenging Sybil-based attacks. We test GossipSub in a testbed environment involving more than 5000 VM nodes deployed on AWS and show that it stays immune to all considered attacks. GossipSub is currently being integrated as the main messaging layer protocol in the Filecoin and the Ethereum 2.0 (ETH2.0) blockchains.

In this talk we will go through the design details of the GossipSub protocol, discuss it's novel points and present a comprehensive performance evaluation study. The talk will serve as a great forum to answer questions and justify the choice of using GossipSub in two of the biggest blockchain networks, namely the Filecoin and ETH2.0 networks.

Having started on a very typical path for open source projects - needing to solve our own problems - we were struck by the challenge that our technology wouldn’t be sufficient for our eventual goal: improving the culture and process of scientific publishing. The challenge is not only technologically broad and complicated - but there are also enormous cultural and operational logistics needed to approach real solutions. Not least of which is the ability to provide resource-constrained, technologically-limited organizations with the stability and support they need to make commitments that will last years if not decades.

We’ll share our experience with PubPub and the Knowledge Futures Group (a non-profit organization dedicated to building digital infrastructure as a public utility), what it’s taught us about building sustainable open source products, and welcome contributions to make our work more supportive and inclusive of the entire knowledge community.

Keystone is an open framework for building customizable trusted execution environments (TEEs) based on RISC-V for various platforms and use cases. Instead of building a single instance of TEE hardware, Keystone provides security primitives, which can be composed by the software framework. The enclave developer and the platform provider can customize the TEE in order to meet their threat models or platform configurations. The Keystone project aims to build an open standard for TEEs by providing a generic and formally-verified interface for a wide range of devices. We envision that every hardware can have a secure TEE with almost no additional cost. In this talk, we will discuss the current state and future directions of the project.

Learn how to provide enhanced media capabilities (such as music on hold playbacks, PIN prompts, barge-in services, etc) to calls that are passing through OpenSIPS SIP Proxy.

SIP proxies, by definition, lack the ability to do any media handling, due to the fact that they only stand in the path of call signalling, but not call media (as opposed to a B2B media server, which behaves as an endpoint for both media and signalling). So, how do you keep your OpenSPIS as a performant SIP proxy, but also enhance your SIP service with extra media capabilities? Starting version 3.1, OpenSIPS provides the means of controlling and changing the RTP streams of the ongoing calls without altering the signalling path of the call (i.e. without transferring the call to a B2B media server), as the calls should be easily resumed to its initial state.

A set of examples where manipulating media in an ongoing call can be useful, while preserving its signalling path, are:

• inject an audio/video announcement

• playback music on hold files

• fork media for call recording, or for call listening

• inject media for call whispering

• temporary barge in an ongoing call

All these features, and many others can be implemented by simply mixing the participants of multiple calls. This presentation describes how all these features can be implemented in OpenSIPS 3.1 using the new Media Exchange module, without changing the SIP signalling path, but only by exchanging SDP bodies between different SIP sessions.

Xlivebg is a system for live wallpapers under X11. It's both a framework for making it easy to create live wallpapers, as well as a set of bundled live wallpapers. The focus of the talk is going to be on what it takes to implement animated wallpapers for the X window system, and on the design decisions and implementation details behind xlivebg.

In the PostgreSQL core, we have the SPGiST index, which is more lightweight and significantly faster than GiST for the supported data types. In many cases, it is the most suitable option for geometric data like points, boxes, etc. An easy way to increase the selection speed is to eliminate the need for the results recheck by a table. But with the index being single-column by design we could not enjoy index-only scans for multicolumn queries.

The talk covers my improvement of the SPGiST access method. Non-key columns can now be included in a single key-column index in a way, similar to that have in GiST and B-tree. This adds the ability to make fast index-only scans for multicolumn queries. Also, non-key columns with data types without SPGiST opclass can be added, which creates an opportunity for the new use cases. In my presentation, I will justify the modification, discuss new use cases of GiST and SPGiST indexes, and share some performance benchmarks.

Software and Hardware Freedom in Health Public Policy
On this panel, we will discuss the extent to which the use of Free Software and open hardware can be used in the public health sector. Software and hardware can help to solve global problems together. The wheel does not always have to be reinvented and through cooperation common innovation can succeed.

The Corona crisis has clearly shown us that we also need to work together in the area of software and hardware. Hackathons were held in various countries, for example, to find software solutions to counter this crisis. The development of tracing apps or solutions for hospitals and health authorities has also shown that Free Software can help many people and that isolated solutions are counterproductive. In the panel we want to discuss what lessons we can learn from the crisis and how Free Software and Open Hardware must be used in the future.

The European Environment for Scientific Software Installations (EESSI, pronounced as “easy”) is a collaboration between different HPC sites and industry partners, with the common goal to set up a shared repository of scientific software installations that can be used on a variety of systems, regardless of which flavor/version of Linux distribution or processor architecture is used, or whether it is a full-size HPC cluster, a cloud environment or a personal workstation.

The EESSI codebase (https://github.com/eessi) is open source and heavily relies on various other open-source software, including Ansible, archspec, CernVM-FS, Cluster-in-the-Cloud, EasyBuild, Gentoo Prefix, Lmod, ReFrame, Singularity, and Terraform.

The concept of the EESSI project was inspired by the Compute Canada software stack, and consists of three main layers: - a filesystem layer leveraging the established CernVM-FS technology, to globally distribute the EESSI software stack; - a compatibility layer using Gentoo Prefix, to ensure compatibility with different client operating systems (different Linux distributions, macOS, Windows Subsystem for Linux); - a software layer, hosting optimized installations of scientific software along with required dependencies, which were built for different processor architectures, and where archspec, EasyBuild and Lmod are leveraged.

We use Ansible for automating the deployment of the EESSI software stack. Terraform is used for creating cloud instances which are used for development, building software, and testing. We also employ ReFrame for testing the different layers of the EESSI project, and the provided installations of scientific software applications. Finally, we use Singularity containers for having clean software build environments and for providing easy access to our software stack, for instance on machines without a native CernVM-FS client.

In this talk, we will present how the EESSI project grew out of a need for more collaboration to tackle the challenges in the changing landscape of scientific software and HPC system architectures. The project structure will be explained in more detail, covering the motivation for the layered approach and the choice of tools, as well as the lessons learned from the work done by Compute Canada. The goals we have in mind and how we plan to achieve them going forward will be outlined.

Finally, we will demonstrate the current pilot version of the project, and give you a feeling of the potential impact.

Here we give a more extensive overview of the free and open-source software that EESSI depends on, and how they are being used in the project.

• Ansible

Ansible (https://www.ansible.com/) is a tool for automation and configuration management. We use Ansible for automating the deployment of the EESSI software stack. This includes, for instance, the installation and configuration of all CernVM-FS components, installing Gentoo Prefix on different CPU architectures, and adding our packages and customizations to the Gentoo Prefix installation.

• archspec

Archspec (https://github.com/archspec/archspec) is a Python library for detecting, querying, and comparing the architecture of a system. In EESSI it is used to find the CPU type of the host system and the software stack in the repository that best matches the host CPU microarchitecture. In the future, we will also use the library to do the same for GPUs.

• CernVM-FS

CernVM-FS (https://cernvm.cern.ch/fs/) is a software distribution service that provides a scalable, read-only, globally distributed filesystem. Clients can mount this filesystem over HTTP. We use CernVM-FS to make the scientific software stack available to any client around the world.

• Cluster-in-the-Cloud

Cluster-in-the-Cloud (https://cluster-in-the-cloud.readthedocs.io/) is a tool that allows you to easily set up a scalable and heterogeneous cluster in the cloud. We leverage this tool to automate software builds on specific architectures, and to test the software installations.

• EasyBuild

EasyBuild (https://easybuilders.github.io/easybuild/) is an installation tool for scientific software, currently supporting over 2,000 packages. By default, EasyBuild optimizes the software for the build host system. We use EasyBuild to install all the different scientific software that we want to include in our stack, and for all the different architectures that we want to support.

• Gentoo Prefix

Gentoo Prefix (https://wiki.gentoo.org/wiki/Project:Prefix) is a Linux distribution that is built from source and can be installed in a given path (the “prefix”). It supports many different architectures, including x86_64, Arm64, POWER, and can be used on both Linux and macOS systems.

• Lmod

Lmod (https://www.tacc.utexas.edu/research-development/tacc-projects/lmod) is an environment modules tool written in Lua, which is used on many different HPC systems to give users intuitive access to software installations. It also allows you to have multiple software versions side-by-side. The EESSI software stack includes an installation of Lmod and environment module files for each scientific software application and its dependencies, providing easy access to those installations to end users.

• ReFrame

ReFrame (https://reframe-hpc.readthedocs.io/) is a high-level regression testing framework for HPC systems. EESSI will be using ReFrame to implement tests (written in Python) for verifying the correctness of the different layers of our project, and doing performance checks of software installations.

• Singularity

Singularity (https://sylabs.io/singularity/) is a container platform that was created to run complex applications on HPC systems. We use it to set up isolated build environments on different kinds of systems, without requiring root privileges. Furthermore, we use it to provide clients with a way to easily access our repository, without having to install a CernVM-FS client.

• Terraform

Terraform (https://www.terraform.io/) is a tool that enables you to easily set up clond instances on demand. We use it to do exactly that, for instance for build machines.

JavaScript runs everywhere. Or so it should! In this 30min talk we're going to skim over 10 small proof of concepts that relied on JavaScript to do something new. We'll conclude with an overview of useful technical and social patterns helpful to run "nearly" JS nearly everywhere.

A computer is an amazing piece of technology because it is generic. It is a general purpose device par excellence. Without going as abstract as Turing machines we wish we could run any code everywhere. Several things get in the way though : performances, design choices, business strategy, available implementation, etc. Yet, when you consider buying a new device or repurposing an old one patterns seem to be coming back over and over again, namely : is a browser present? Can I run a web server on it? Which protocols are available? Is there any usable file format to send or receive data? By efficiently identifying those new opportunities emerge. One can then connect one device to another even if they are not your usual computer. This talk is going to explore such patterns through 10 small examples built over last year. From a vibrating sex toy available on a social VR platform to a Linux phone controlling a TV like a remote or a virtual light bulb controlled by strangers and matching its physical equivalent, exotic hardware is going to leverage JavaScript, one way or another.

This presentation targets a curious audience. Basic knowledge of JavaScript, Internet of Things, virtual reality, augmented reality, embedded devices are welcomed but not necessary. The slides provide links to code snippets and all used libraries.

How to compose the configuration and secrets of microservices taking into account various variables without dying in the attempt.

In a micro service based architecture it's common to have to manage configurations and secrets based on different variables, such as the microservice, flavors of the microservice, the execution environment and data center, etc. Since it is an arduous task both in the time needed to add a new variable and to refactor existing ones I have created MHConfig.

MHConfig is a microservice in charge of composing configurations and secrets according to different labels and notifying the clients who use it when a change has occurred, providing various features to facilitate this work as references to recurrent or global values, traceability of the clients using a configuration, access control lists to prevent obtain to other microservice configurations/secrets, etc.

In this session I'm going to talk about how the tool works and how it can help solve common problems when managing configurations and secrets in a complex environment.

Using a new collaboration tools can be a challenge when it comes to pre-existing information. In this talk, we will look at available solutions when migrating data to the XWiki Open Source software.

We will first review the differences between XWiki and alternate systems, namely Atlassian Confluence, Microsoft Sharepoint and document management systems. Secondly we will show multiple approaches to migrating data into XWiki and improving the quality of the information available. Finally we will demonstrate existing importing tools available in XWiki: Confluence Import & XWiki Batch Import.

During 2020 we spent the year working with the maintainers of pip, the Python package manager. The project was to implement a new dependency resolver and improve pip's usability. It was a difficult project as personally, I knew very little about software package managers apart from doing "pip install". How do you do UX design with a piece of software used by hundreds of thousands (possibly millions!) of users on a small budget? Where do you find those users? Combined with this the maintainers were under pressure to do a lot of complicated work in a short period of time.

This session will be a recorded discussion between the UX designers and the pip maintainers. We'll talk about what it was like to spend a year working together, the challenges, and the lessons we can teach others. We'll leave 5 minutes (approx) at the end for Q&A.

In this talk we'll see how we can call Python function from Go "in memory" and with close to none serialization.

Like tools, programming languages tend to solve problems they are designed to. You can use a knife to tighten a screw, but it’s better to use a screwdriver. Plus there is less chance of you getting hurt in the process.

The Go programming language shines when writing high throughput services, and Python shines when used for data science. In this talk we'll explore a way to call Python/numpy code from Go in memory using some cgo glue. This approach is fast and risky, use at your own risk.

The database market is changing drastically in ways no one imagined 5 years ago. Database vendors are moving away from traditional deployment methods and embracing database as a service (DBaaS) as the default method to offer their database technologies to consumers and users. Much of this movement has been built because of the success and popularity of DBaaS offerings by major cloud vendors. Unfortunately, this is leading to a new era of NROSS (Not really open source) technologies that pretend to be free, open, and transparent but simply are not. As people wake up from the hangover’s caused by the incompatibilities, lack of portability, and increased costs they are looking at how to reclaim the openness, transparency, and freedom true OpenSource has provided them in the past. We will explore the trends and give his opinions and ideas on how we need to disrupt the current trends to keep open source open, and give users the freedom of having a quality alternative.

Applications built with Holochain are highly modular. This makes it easy to share code and compose smaller pieces together into larger wholes. Each functional part of a Holochain application, called a DNA, has its own set of rules, private network, and distributed database.

This session will dive into the basic concepts of Holochain app architecture covering the building blocks of DNAs, membranes, data validation and more.

What ideas do you have? Let’s architect them on the fly!

Your databases and monitoring are all set up and you've got your MySQL and MongoDB databases figured out - you're monitoring them and everything is fine. You're killing off those occasional monster queries and you have it all in check. But now you've been tasked to keep tabs on that new Cassandra cluster your company has - we'll show you how to incorporate monitoring it into the Percona Monitoring and Management tool and which features enable you to get the best out of any new and existing database you're incorporating. Database problems? Not on your watch.

You will also find out how to include other databases into PMM as a handy open source tool you can use to monitor your databases. You're invited to ask questions during this presentation as well as in the Q&A section.

We introduce the concept of a VAA by example of the well-known German "Wahl-O-Mat" and show how to run an election compass for your hometown using the free and open source OpenElectionCompass.

A voting advice application is a great way to support elections and democracy as a whole by making the parties or candidates more transparent and comparable. The differences between political parties are often difficult to understand for the voters, especially for first-time voters. To make elections more accessible some countries have started to offer election compasses, or VAAs. Services like these help citizens getting to know the parties or candidates by presenting a carefully chosen collection of political statements. The users and the parties both take position to these statements. Based on this, voters can quickly get a comparison between their own opinions and the positions of the parties. In Germany, this service is implemented by the bpb, the Federal Agency for Civic Education and is called "Wahl-O-Mat". In the Netherlands this concept is called "StemWijzer". Software like this has developed in the early 2000s and evolved ever since. Running such a project offers great value to citizens, the political system and our democracy. It is also very expensive. Implementing an election compass is not only time consuming, but also requires great technical knowledge. Usually, there is no election compass for smaller elections, because hiring software developers is simply out of budget.

OpenElectionCompass offers a free alternative – free as in free speech as well as in free beer. The requirements for a voting advice application are very similar, be it for a small or a national election, for an election in Berlin or an election in Brussels. OpenElectionCompass aims to provide a free solution, simple to configure, customize and deploy. By continuously improving our project, we have an advantage over agencies doing this only every few years. And by not developing behind closed doors, we are transparent and open for everyone.

This talk will give an introduction to the concept of VAAs and introduce you to the benefits of the OpenElectionCompass to help you run your own voting advice application.

In this talk, I'd like to give brief information about how to shard your data under MariaDB topologies and the possibility of using frameworks such as Vitess. While discussing the pros and cons of sharding I would like to showcase how structured horizontal sharding can scale your database almost infinitely. The audience will benefit from how others sharding to scale unlimited under both cloud and Kubernetes realm. In this short talk, I'd like to demo a case study that can be an example to get started for many.

Vitess is a database clustering system for horizontal scaling of MySQL through sharding. By enabling shard-routing logic, Vitess allows application code and database queries to remain agnostic to the distribution of data onto multiple shards. With Vitess, you can split, merge, and migrate shards as your needs grow. With its compatibility to development frameworks and integration to open-source tools, Vitess has been a core component of several high traffic OLTP sites around the world and serving data across different platforms. Vitess is also the first Linux Foundation/Cloud Native Computing Foundation graduated open-source database project.

One of Zig's main goals is seamless cross-compilation from any target to any target. This includes macOS and Apple's recent switch from x64 to ARM64 architecture with the introduction of the M1 SoC. This talk will delve deep into the internals of Mach-O linking in ZIg for both x64 and ARM64 targets, discussing new strict requirements the ARM64-version of the XNU kernel places on the binaries such as embedded code signature and inode caching, and how Zig mustered up to address and solve them for fantastic developer experience on macOS.

I hope for this talk to deliver on two fronts: 1) to showcase and convince the audience that Zig takes cross-compilation very seriously and is a language worth learning, and 2) demistify Mach-O linking in general. Yet another great strength of Zig is that it is a very readable language, therefore, even though the code examples will be in Zig, it will not hinder anyone's ability to enjoy figuring out the finer points of Mach-O linking on ARM64 aka the Apple Silicon which are language-agnostic. Finally, there naturally will be coding examples interleaved here and there to demonstrate the different linking concepts that the talk will touch upon.

Why is it so hard to detect the licensing and copyright information of source code? Because it is a tedious and often confusing task for developers to provide this information. The REUSE project changes that! With three simple steps, it makes adding and reading licensing and copyright information easy for both humans and machines. This presentation will guide you through the REUSE best practices and presents how to make clear licensing simple.

In 2017, the FSFE started the REUSE initiative. The main goal is to make it easier for developers to declare the licensing and copyright situation for their code. Especially in common scenarios where a repository contains code from various sources under different licenses with multiple copyright holders, it often becomes complex for everyone who wants to legally reuse code.

Therefore, REUSE provides best practices that aim to be compatible with already existing recommendations and still cover also complex projects and their edge cases. The result is that for a REUSE compatible repository, every single file in some way carries information about its license and copyright holder(s), with the full license text(s) available.

To make adoption as easy as possible, REUSE offers tools and accompanying documentation. Thanks to this, we already see hundreds of projects being REUSE compliant already. The more projects follow the best practices, the easier developers can reuse their code safely and thereby contribute to a system in which you do not need a lawyer to license your code.

The Law Factory is a research project which attempts to make it easier to observe the law-making process in the French Parliament. It allows to track down the different steps of the parliament process, to identify when a particular piece of law was introduced, and to look at all the amendments and the debates per article. The software is fully open-source, based on Python 3 for the data collection. It's a common project of the association Regards Citoyens, the médialab research lab of Sciences Po Paris and the Centre d’Études Européennes et de Politique Comparée.

In this Talk we will present the work done and the research output produced.

SIP3 is an advanced monitoring and troubleshooting platform. It recently released a few very powerful APIs which you can use to build your own telecom solutions. In the presentation I will show how we used these APIs to implement Wangiri fraud detection service.

IETF is discussing Trusted Execution Environment Provisioning (TEEP) protocol to manage remote installation/update/deletion of a TA (Trusted Application) in TEE (Trusted Execution Environment) which provides hardware isolated environment in the CPU. TEEP is designed to be general among different CPU architectures. We have implementation of TEEP on the new RISC-V cpu. Our implementation is designed to be portable to another TEE architecture. The requirement for portability is discussed at the event.

IETF is discussing Trusted Execution Environment Provisioning (TEEP) protocol to manage remote installation/update/deletion of a TA (Trusted Application) in TEE (Trusted Execution Environment) which provides hardware isolated environment in the CPU. TEEP is designed to be general among different CPU architectures, but primary implementations are proceeding on Intel SGX and ARM TrustZone. Therefore, we have implemented of TEEP on Keystone which is a TEE project on RISC-V led by UC Berkeley.

TEEP consists of 3 major software components; “TEEP Broker” on the normal OS, “TEEP Agent” in the TEE, and “Trusted Application Manager (TAM)” on a remote server. These components manage certificates for authenticating TEE and TAM, and code signing of TA. All of the certificates are based on PKI key management. The challenges of having TEEP functionality on RISC-V is how to minimize the complexity of required features of TEEP inside TEE while keeping the portability of existing TA. The TEE is not meant to have full scale of POSIX API development environment which are convenient for developer but not ideal for minimizing security who would like to focus on code size.

Some of the features we have added to Keystone runtime are HTTP/HTTPS and Concise Binary Object Representation (CBOR) parser.

Our initial implementation of TEEP was implemented on Arm TrustZone with OP-TEE and then moved to Keystone on RISC-V. The presentation will also include instruction of basic concept and design of TEEP.

I will demonstrate how to write a vectorized (parallel) Caesar cipher in RISC-V (in assembler) using the project's emulator. Using the emulator is necessary at this point for such an application because the vectorized extension to the RISC-V ISA is not standardized. I will further demonstrate how the emulator itself is able to emulate the execution of a single user-space application when it is actually designed to emulate an entire system. This will involve a demonstration and explanation of riscv-isa-sim, riscv-pk and their interaction.

The talk will discuss using the Apache Groovy programming language with Apache OpenOffice UNO API's and some associated projects that allow this to happen. Projects include the Groovy UNO Extension that adds convenience methods to the OpenOffice API's allowing less coding, an OpenOffice Extension that adds Groovy as a macro language to the office, and an associated extension to add sample macros to the office written in Groovy. Examples of usages like Groovy scripts as OpenOffice client applications, OpenOffice macros in Groovy, and a compiled OpenOffice extension application in Groovy.

Cluster API is a Kubernetes sub-project focused on providing declarative APIs and tooling to simplify provisioning, upgrading, and operating multiple Kubernetes clusters. Cluster API provides clusterctl, which can be configured with environment variables and allows the generation of Kubernetes manifests that describe your workload clusters. While this provides a great on-boarding experience, managing and wrangling more YAML isn't something we're all yearning to do. Fortunately, there's a better way. Introducing Cluster API bindings for TypeScript, Go, and Python. In this talk, I'll introduce you to managing Cluster API through your favourite programming languages.

Cluster API is a Kubernetes sub-project focused on providing declarative APIs and tooling to simplify provisioning, upgrading, and operating multiple Kubernetes clusters. Cluster API provides clusterctl, which can be configured with environment variables and allows the generation of Kubernetes manifests that describe your workload clusters. While this provides a great on-boarding experience, managing and wrangling more YAML isn't something we're all yearning to do. Fortunately, there's a better way. Introducing Cluster API bindings for TypeScript, Go, and Python. In this talk, I'll introduce you to managing Cluster API through your favourite programming languages. Cluster API is a great piece of technology, but managing and constructing the YAML can be painful and difficult. This talk introduces the audience to using Pulumi and custom built libraries for exposing Cluster API via TypeScript, Go, and Python.

There is no better place than a university to develop open source software that you can turn into a startup. Along the way you can get (but don't have to) a Ph.D. When the time is right, you can spin out from the university with substantial state funding, which helps you avoid venture capital (and losing equity early). In this talk, I explain how it works (in Germany). I welcome specific proposals, and I am hiring for my existing open source research projects and startups.

XALT is a tool run on clusters to find out what programs and libraries are run. XALT uses the environment variable LD_PRELOAD to attach a shared library to execute code before and after main(). This means that the XALT shared library is a developer on every program run under linux. This shared library is part of every program run. This talk will discuss the various lessons about routine names and memory usage. Adding XALT to track container usage presents new issues because of what shared libraries are available in the container.

XALT is an open source project under the LGPL licence. It is available at https://github.com/xalt/xalt and the documentation can be found at https://xalt.readthedocs.io. A presentation can be found at: https://www.youtube.com/watch?v=6QSKaAkbiWo?

HTML-validate is an offline, strict and customizable HTML5 validator with support for custom elements, partial templates and fully extendable. This talk will describe why validation matters and how you can integrate it with your tooling and frameworks.

2020 was an isolating year. During a time of travel restrictions and social distancing, Mozilla Hubs (hubs.mozilla.com) provided a safe place for people to come together virtually. This open source project allows users to quickly create custom 3D spaces, and invite others to join using only a link. It is browser-based, and works across a wide variety of devices - no downloads required.

From conferences, to weddings, to art galleries and even windsurfing lessons, over the last year we’ve seen a huge variety of creative applications that our team had never imagined. In this talk I showcase exciting work created by the Hubs community, and share specific insights learned while managing Hubs’ rapidly growing user-base. Attendees will discover how to foster an open, accessible & delightful community.

kris nóva fills in for a cancelled talk

talking about unit tests, TestMain() and reverse engineering an API with Go

My talk will be structured as follows followed by a short Q&A,

• Why do I need to learn to code?
• Helping OSS as a Developer-Designer
• The approach to coding for OSS complexity
• Stuff to keep in mind to make meaningful contributions
• How to tackle a particular issue?
• Receiving code reviews effectively
• Where do I go ahead with all this new found knowledge?

RISC-V is a relatively new ISA and platform, which has been evolving rapidly. A few Linux distributions already have good support and have compiled most of their packages for it. The boot process has been neglected and only recently did everyone start using the widely used embedded bootloader U-Boot instead of a custom research bootloader. We have ported the EDK2 reference implementation of UEFI to make the boot process more like current desktops and servers. This talk explains how we did that, how it works and how we got Linux to boot. We also want to explain what's left to do and how we can move in the direction of a RISC-V server platform.

Java Byte code is OS independent, which means that your application's startup takes more time than a native image. Using the Class Data Sharing functionality introduced in more recent versions of the JVM, you can prepare your application so that it will load very fast.

In this presentation, I'll go into more detail what Class Data Sharing is and how you can use it on an OpenJDK versions. With some Jakarta EE demo applications, you will see gains that you can achieve and reduce memory footprint a lot in Docker containers by sharing memory.

Artificial intelligence, machine learning, and deep learning are intertwined capabilities that attempt to solve problems that defy traditional computational solutions — problems include fraud detection, voice recognition, and search result recommendations. While they defy simple computation, they are computationally expensive, involving computation of perhaps millions of probabilities and weights. While these computations can be done outside of the database, there are specific advantages of doing machine learning inside the database, close to where the data is stored. This presentation explains how to do machine learning inside the Postgres database.

The Xilinx ZynqMP SoC includes a powerful H.264/H.265 Video Codec Unit (VCU) which Xilinx supports with an out-of-tree driver and user space library. The allegro driver from mainline Linux allows to use the VCU using the standard V4L2 encoder API without requiring any custom user space.

I will explain why I wrote the driver, show how the VCU is used from a driver perspective, and present the current state of the driver and which features are still missing.

The Zynq UltraScale+ MPSoC integrates several ARM cores and an FPGA into a single chip. One variant of this SoC includes an H.264/H.265 Allegro DVT Video Codec Unit (VCU).

Although Xilinx did a good job supporting the ZynqMP in mainline Linux, the VCU was originally only supported via an out-of-tree driver. It consists of a user space library and a firmware blob, which interact via a custom IOCTL interface. Unfortunately, this has security implications as the user space handles physical buffer addresses.

Fortunately, the V4L2 mem2mem device API for video codecs avoids this problem by using abstract DMA buffers. Many applications already use these APIs, and various drivers for hardware codecs already implement these APIs. Thus, a V4L2 driver for the VCU allows reusing existing applications such as FFmpeg and GStreamer on the ZynqMP.

A broken MariaDB means broken Application, so maintaining insights in MariaDB operational performance is critical. Thankfully MariaDB offers a lot in terms of observability to resolve problems quickly and get great insights into opportunities for optimization. In this talk, we will cover the most important observability improvements in MariaDB ranging from Performance Schema and Information Schema to enhanced error logging and optimizer trace. If you're a Developer or DBA passionate about Observability or just want to be empowered to resolve MariaDB problems quickly and efficiently you should attend this talk.

Trusted RV is a combination of 4 core 64bit RISC-V (AC: Application Core) and 1 core 32bit RISC-V Secure Coprocessor (SU: Secure Unit). The SU works as a "Root of Trust" and keeps critical information (e.g., Device Key, Certificate). The SU boots before the 64Bit RISC-V and controls it (i.e., secure boot, etc). The communication from the AC to the SU is limited for TEE (i.e., Keystone Encalve) only and keeps security. Trusted RV is implemented on an FPGA (Xilinx VC707) and a simulator.

We have developed the Trusted RV which is a combination of 4 core 64bit RISC-V and 1 core 32bit RISC-V Secure Coprocessor. The secure coprocessor works as a "Root of Trust" and keeps critical information (e.g., Device Key, Certificate). The secure coprocessor offers machine mode only and runs Zephyr OS. The Zephyr OS includes crypto and certificate-verification libraries and manages the 64bit RISC-V. The secure coprocessor boots before the 64bit RISC-V and verifies it.

The secure coprocessor is tightened with RISC-V Keystone on the 64bit RISC-V to keep security. The 64bit RISC-V runs Keystone as TEE (Trusted Execution Environment), and Secure Monitor (SM) runs on machine mode under the Linux kernel. The secure communication between 64bit RISC-V and Secure Coprocessor is managed by SM only. The communication is passed to a Trusted Application (TA) in a Keystone Enclave only. The secure communication is implanted on the shared memory and mutual interrupts between 64bit RISC-V and Secure Coprocessor. This mechanism is also used for the remote attestation of Keystone which based on the key in the secure coprocessor. The Trusted RV is implemented on a simulator for software development, as well as FPGA (Xilinx VC707).

RAWGraphs is an open source web application for the creation of static data visualisations that are designed to be further modified. Originally conceived for graphic designers to provide a series of tasks not available with other tools, it evolved into a platform widely used in research and data journalism contexts that provides simple ways to map data dimensions onto visual variables. It presents a chart-based approach to data visualisation: each visual model is an independent module exposing different visual variables that can be used to map data dimensions. Consequently, users can create complex data visualisations. Finally, the tool is meant to produce outputs that are open, that is, not subjected to proprietary solutions, which can be further edited. Thanks to an intuitive user interface and experience drafting visualizations become an easy task, enabling the user to produce the visualizations not only as a mere output but also as a tool within the research process. Last year we launched a successful crowdfunding campaign to raise funds for the redesign and development of a new version of RAWGraphs, that will be released in the first months of 2021. The new version is written from scratch with the aim to make the tool more flexible for customisation and to create an active community also on the development side. The talk aims at presenting how RAWGraphs has been used in research context and our strategies to keep the project free, open source, economically sustainable and independent.

The lrerpxy module is a new module for Kamailio for relaying media session in kernel space linux. The related paper of this module is accepted in 10th International Conference on Computer and Knowledge Engineering (ICCKE2020) October 29-30, 2020. (https://ieeexplore.ieee.org/document/9303608) Also the silde of my presentation is published in: https://www.slideshare.net/mespio/lreproxy-module-for-kamailio-presenation

The IP Multimedia Subsystem is an architectural network for delivering IP multimedia services and data. The IMS network has built on three layers which allows for the convergence of different access networks. Each layer in IMS is consisting of various elements and protocols that consequently process signaling or media flow to specific application service. While the Call Session Control Function (CSCF) is the main route decision of the IMS network, the most significant of resources are used by routing and delivering media flow in Transport data layer in IMS network. With raising of request for service in IMS, the usage of resource have been increased. The ingress and egress nodes in IMS network are critical points and could potentially being bottleneck because they have to transmit huge signaling and media packets from and to IMS network. In this paper, we focused on Transport data layer on Edge-Border IMS network to manage and optimize its resources. We propose a new model of proxy that is called LREProxy. We implement LREProxy as new module for Kamailio, Open Source SIP Server.

As most of modern traffic is now encrypted, deep packet inspection is becoming a key component for providing visibility in network traffic. nDPI is an open source toolkit able to detect application protocols both in plain text and encrypted traffic, extract metadata information, and detect relevant cybersecurity information. This talk shows how nDPI can be used in real life to monitor network traffic, report key information metrics and detect malicious communications.

The pervasive use of encrypted protocols and new communication paradigms based on mobile and home IoT devices has obsoleted traffic analysis techniques that relied on clear text analysis. DPI (Deep Packet Inspection) is a key component to provide network visibility on network traffic. nDPI is an open source toolkit designed to detect application protocols on both plain and encrypted traffic. it is also able to extract relevant metadata information including metrics on encrypted traffic for easy classification and accounting. This talk introduces nDPI, demonstrate how to use it in real life examples, and it presents how it can be effectively used not only for traffic monitoring but also in cybersecurity being it able to detect unusual traffic behaviour and security issues.

Cerberus, in reference to the Greek mythology of the three-headed god, guardian of Hell, was the name given to the internal testing automation solution we decided to build internally in 2011. At that time, the ecosystem of existing solutions, being commercial or open source, was not fulfilling our requirements for end-to-end functional testing. In this article we will explain how our internal solution evolved from a Proof of Concept to a broader deploy in other major companies, to perform Continuous Delivery, Continuous Testing and Monitoring at scale.

For the past few decades, radio astronomy has been a rapidly developing area of observational astronomy. This is due to the fact that a variety of celestial objects emit electromagnetic radiation at radio wavelengths, which has led to the development of radio telescopes capable of revealing the otherwise-hidden astrophysical properties of the universe. An important requirement that makes radio astronomy observations and analysis possible is an appropriate software pipeline compatible with the spectrometers with which radio observatories are equipped. In this work, we present Virgo: a versatile software solution for radio telescopes.

Virgo is an easy-to-use open-source spectrometer and radiometer based on Python and GNU Radio (GR) that is conveniently applicable to any radio telescope working with a GR-supported software-defined radio (SDR). In addition to data acquisition, Virgo also carries out automated analysis of the recorded samples, producing an averaged spectrum, a calibrated spectrum, a dynamic spectrum (waterfall), a time series (power vs time) and a total power distribution plot.

By additionally providing the observer with an important set of utilities, Virgo also makes for a great tool for planning (radio) observations. This includes the ability to compute the position of astronomical sources in the sky for a given date, estimate the right ascension and declination given the observer's coordinates along with the altitude and azimuth the telescope is pointing to and convert equatorial to galactic coordinates with the help of the open-source Astropy package.

Financing open source using tax breaks on donations made to endowment funds or general interest associations is a construct available in France and a viable alternative to R&D expenditures for sponsoring open source projects. We will present several initiatives from the Libre Endowment Fund ("Fonds de Dotation du Libre" in French) - from financing feature development of open source software to releasing a 4G/5G base station as open source hardware or supporting litigation against the French government's decision to host Health Data on Microsoft servers.

The recently published FOSS contributor report showed that 48.7% of contributors were paid for their contributions by their employer with only 2.95% being paid by a third party. So even today as (open source) software continues to eat the world, almost half of all projects lack the financial base for ensuring their respective software's long-term existence.

To finance the long term maintenance of its open source software stack, Nexedi has created the Libre Endowment Fund ("Fonds de Dotation du Libre" or FDL in French). It is a French endowment fund which complies with strict auditing procedures. With this status, French Law permits corporations and individuals to donate to the FDL and claim back up to 60% from future income taxes (65% for individuals). Rather than investing directly in the maintenance or continuous development of own or third party solutions, Nexedi and other companies (ex. Amarisoft) can pool donations which then support the maintenance or development of open source software, open source hardware or open services.

During the last three years, FDL has been involved in a variety of projects:

1) "Open Source Software" - FDL sponsored the development of Jexcel v4, an open source online spreadsheet editor ;

2) "Open Source Hardware" - FDL has acquired the technological assets for a remote radio head (RHH) and is about to publish its PCB design and BOM under open source licence. It will be the first open source carrier-grade 4G/5G base station ;

3) "Open Service" - FDL is supporting the launch of an initiative called "HyperOpen" for cloud solutions built using open source software, open hardware and open service. Open Service applies to the service industry the four freedoms of Free Free Software. With Open Service, everyone can use a service, study how a service is made, modify the service and become provider of that service. It is a generic principle, that in theory can be applied to services beyond the cloud.

4) "Open Data" - FDL maintains a directory of European Open Source software publishers and their success cases. This directory is shared and contributed as open data (JSON) through pull-requests on a git platform.

5) "Open Policy" - FDL is helping to sponsor the legal cost of Santenathon, a group of IT companies and non-profit organisations who have recently succeeded in a court case asking the French government's Health Data Hub to stop collecting personal data of french citizens and to migrate their solution from Microsoft to a European provider.

The examples should highlight that provided the legal conditions in a respective country, funding of FLOSS solutions and related general interest projects can be partially subsidized by tax exemptions. It is important to notice that strict accounting and reporting rules apply in order to ensure juridical safety of the donor. FDL is managed using an open source ERP by a professional accountant and auditor. Those costs can be shared among the different projects.

FDL also benefits from a scientific board of advisors which include three developers of open source software (Jean-Paul Smets, Stéfane Fermigier, Gaël Varoquaux) who also hold a PhD in computer science or mathematics. This scientific board follows the same procedures as governement sponsored RTD projects and thus also contributes to the juridical safety of FDL.

Emulator authors often like to measure themselves by invoking the concept of cycle perfection. In practice that under- or over-samples many real machines. This talk instead floats a bus-centric model of emulation.

James Kulina, Executive Director of OpenPOWER Foundation will be giving introduction to the Foundation and outlook for 2021 and beyond.

Open up your design process is good for your creative health. How can we shift the design perspective to be more focused on the process than on the result? How can we collaborate openly with frameworks that help us learn from each other and build on each other's ideas?

Open design can help transform organizations and projects by just unveiling the creative potential we all have within. We can learn how to dot, but we need to learn that together. In this talk, you will find inspiration and examples of how open design processes and frameworks can disrupt today's creative production.

With the growing popularity of Go many people are asking how to build a solid GUI. The language design to target concurrency and portability makes it a great match for cross-platform development. This talk shows how the Fyne toolkit is designed to help make beautiful and idiomatic native apps with Go.

This talk explores the Fyne toolkit and what is new with the recently released version 2.0. We will explore the main features including canvas, widgets, data binding, test support and app store packaging.

We will step through how to build an application using standard widgets, data binding and storage, and then see how it can be distributed for practically all graphical operating systems and app stores.

SemApps is a collaborative, interoperable, generic and modular knowledge management system :

• Based on linked data & semantic web technologies and the SOLID specification, it allows the co-production of knowledge graphs.
• Built on open standards, it enables the development of interoperable information systems.
• Designed on a modular architecture, it gives everyone the opportunity to build and customize platforms on demand.

SemApps is an open-source software project whose development is coordinated by the Virtual Assembly (VA), a French-based non-profit organization bringing together about fifty developers and activists.

In a context of strong fragmentation of dynamics in the field of transition, VA aims to develop commons (digital tools, methodologies and projects) to promote the interconnection of transition movements.

SemApps is one of the Virtual Assembly's core projects. Its mission is to foster interconnections between communities by creating synergies between their information systems.

SemApps is a collaborative, interoperable, generic and modular knowledge management system : - Based on semantic web technologies and the SOLID specification, it allows the co-production of knowledge graphs. - Built on open standards, it enables the development of interoperable information systems. - Designed on a modular architecture, it gives everyone the opportunity to build and customize platforms on demand.

Its code is released under the Apache 2.0 free license.

Transform Release Management role from System administration to software development for Release operations thru GitOps practices

Transform Release Management role from System administration to software development for Release operations thru GitOps practices Shipping operational knowledge into a software is a big milestone towards better configuration management. In this talk, I will explain how we introduced configuration management practices into release management team while leveraging the software engineering principles during this journey. I will start by clarifying what problem(s) were we trying to solve, namely: Lack of system Reliability, huge dependencies among silos, Rework between Dev, QA and release teams. Then, I will explain the solution that I proposed to solve these problems, namely: Service Offering Model, Killing environments gap and treating everything as CI (Configuration item). After that , I will move forward on challenges that I faced while trying to solve the issue: migration from Legacy system, security compliance & disconnected environment, .. and others. Finally, I will give overview about the solution implementation.

When writing policy as code, we aim to implement the best practices in our work, but we might not always know how to iterate on policies, nor how to make them transparent to the teams we work with. The best way to enforce policy is to make it easy and to incorporate these practices into an automated pipeline that will make for efficient workflows and by making all policies visible to end-users. We will demonstrate using the Open Policy Agent, Terraform, and Flux in a declarative fashion.

In this session we are presenting our experiences with migrating from traditional HPC to cloud-native HPC using a compute-heavy scientific workflow that is usually carried out on national supercomputing centers. Our scientific application are atomistic biomolecular simulations using the GROMACS molecular dynamics simulation toolkit.

Molecular dynamics simulations are computationally challenging in two respects: First, individual simulations usually need to be parallelized over as many resources (cores, GPUs, nodes) as practicable, to reduce the time to solution from months down to weeks or possibly less. Second, we as scientists are not so much interested in individual simulations, but rather in average properties of the simulated systems. The latter can however only be addressed with ensemble runs of many (typically hundreds) slightly different replicas of the system, thus requiring an enormous amount of compute time.

Cloud-based HPC can address both challenges: The cloud offers as much compute time as desired, plus the possibility to efficiently scale individual simulations over multiple instances connected by a high-performance interconnect. We build a cloud-based HPC cluster in a straightforward and reproducible way by simplifying software management with SPACK and cluster lifecycle management with AWS ParallelCluster. With the SPACK package manager, diverse hardware is easily incorporated into a single cluster, e.g. instances with AMD, ARM, and Intel processors, instances with (multiple) GPUs and instances with high-performance interconnect.

On the cluster, we used several representative biomolecular systems to benchmark the GROMACS performance on a various hardware available in the cloud, both on individual instances as well as across multiple instances. This way we uncover which instances deliver the highest performance or the best performance-to-price ratio for GROMACS simulations.

As a next step, we are preparing to run a large ensemble consisting of 20,000 individual simulations in the cloud using all resources that are globally available to reduce the time to solution as much as possible. In principle, such an ensemble simulation - which would occupy a medium-sized compute cluster for weeks or even months - could then finish within a day. Containerization will be a key concept here to provide a common software environment across a vast variety of hardware.

The reliability and performance of Open Source database solutions can’t be contested. They are fast and they are stable, but they fell short of integrating nicely with the latest data science and research workflows.

If you store your data in MariaDB or even other database systems from the MySQL family, I am proud to let you know we have been working hard to create a beautiful Open Source friendship between the MariaDB Server and the Jupyter ecosystem.

The MariaDB Jupyter kernel aims to improve the interaction with your data, it allows you to run MariaDB directly in a Jupyter notebook. You can display the results of your favorite SELECTs in Matplotlib graphics or export them into a DataFrame in another Python Notebook through database specific %magic commands.

This talk covers the current state of the MariaDB kernel, the existing features, how to install and use it and how we imagine it should look like in terms of functionalities in the near future.

It also explains the inner structure of the kernel, how to pass different configuration options and shows demos for some of the most common use cases.

There is no background knowledge expected to understand the content of this talk, if you've ever used a Jupyter notebook, a SQL database or both, or you'd just love to learn about these technologies, you're more than welcome to attend.

In this talk, James Curtis, lead developer at OpusVL, will explain the complex compliance challenge faced when working on a variety of projects for different customers, each having overlapping and separate areas of Open Source code.

He will explain the approach taken to automating the process by connecting up the software release pipeline through Continuous Integration (CI) tooling to deliver OpenChain compliance reporting.

This will cover the path from developer and version control through testing and finally to the hosted container image. The tools and processes will be shared as well as the current state - this is a new subject area so it is constantly being developed, and all based on freely available Open Source components.

The development of this process was funded by Innovate UK through the (DITO project (https://dito.tech).

Container images based on Alpine Linux have been around for some time. You can calculate the real cost savings from using small containers, which we will do. And now it's time to have them as an official flavor of Java Runtime with new JEP 386: Alpine Linux Port. The new port has its own subtleties, which we will consider in the context of microservices development.

BellSoft is the company behind JEP 386 and we would like to share our work in the OpenJDK community. We have long been providing Liberica JDK Docker images on top of Alpine Linux. It really helps our users and therefore remains the most popular choice.

The presentation tries to reveal a list of open source small applications that are typically not in focus, but very useful for helping to build RTC applications, troubleshoot or operate SIP-based platforms. Among others, they can be used to automatize, monitor or simulate endpoints for new features or scenarios, saving time and reducing costs during the development and testing phases. The scope is also to engage the audience to share their experiences and let everyone know about other tools.

Bitswap is a Block Exchange protocol designed for P2P Content Addressable Networks. It leverages merkle-linked graphs in order to parallelize retrieval and verify content integrity. Bitswap is being used in the InterPlanetary File System architecture as the main content exchange protocol, as well as in the Filecoin network as part of the block synchronisation protocol. In this work, we present Bitswap’s baseline design and then apply several new extensions with the goal of improving Bitswap’s efficiency and efficacy and minimizing its bandwidth fingerprint. Most importantly, our extensions result in a substantial increase to the protocol’s content discovery rate. This is achieved by using the wealth of information that the protocol acquires from the content routing subsystem to make smarter decisions on where to fetch the content from.

This talk is focused on sharing the operation of Bitswap, the testbed we build to test improvements of Bitswap, and the ways in which we improved Bitswap building the foundation for research lines on file-sharing in P2P networks.

Datasette is a tool for exploring and publishing data. It helps people take data of any shape or size, analyze and explore it, and publish it as an interactive website and accompanying API.

Datasette is aimed at data journalists, museum curators, archivists, local governments and anyone else who has data that they wish to share with the world. It is part of a wider ecosystem of tools and plugins dedicated to making working with structured data as productive as possible.

I’ll use this talk to introduce Datasette and show how it can be used to quickly explore and publish data.

I’ll talk about why SQLite is an ideal publishing format for structured data and demonstrate several open source tools for converting data from different sources into SQLite databases for use with Datasette.

Datasette is the foundation of my Dogsheep personal data warehouse project. I’ll show how I’ve pulled together data about my own life from a wide range of sources - from Twitter and GitHub to 23AndMe and Apple Health - and used it to build my own data warehouse to help me answer questions about myself.

[NO PRERECORDED VIDEO, WILL RUN AS BOF]

The Apache OpenOffice Project maintains two websites: (1) www.openoffice.org (2) openoffice.apache.org. The two website structures will be discussed. It is now possible to contribute to both of these websites via GitHub Pull Requests

CHERI is a portable architectural extension providing spatial, referential, and temporal memory safety along with strong, light-weight compartmentalization. CheriBSD is a port of FreeBSD supporting CHERI on Arm Morello, MIPS, and RISC-V. CheriBSD is the reference POSIX OS implementation for CHERI.

CheriBSD supports unmodified binaries from the native architecture plus CheriABI programs which have strong spatial, referential, and temporal safety guarantees. I will discuss our implementation of CheriBSD with a focus on CheriABI.

Visual Studio Code is an extremely popular editor and has a very rich ecosystem of extensions. However, testing these extensions is rather tricky in practice. Often extensions require external resources which have to be injected into the development environment. Unit tests are quite bad at testing the UI itself, as they require extensive setup code and a lot of mocking (= implementation of the production API in the testing environment that exposes the same interface). Checking the results of them still requires one to manually verify that the UI looks correct. All this combined can easily lead to false-positives and false-negatives. Integration tests on the other hand are not a silver bullet either as they can be rather brittle, slow, lengthy to write, hard to set up while also not being able to cover edge-cases very efficiently. This talk will focus on what we learned while developing the Open Build Service Connector: which testing strategies work, which don't and what tools to use. We will cover some viable approaches to unit testing and the vscode-extension-tester module that we used for integration tests.

This talk shows how ntopng, an open source monitoring application, can be profitably used to discover, characterise, classify and enforce network traffic policies.

ntopng is an open-source passive traffic monitoring tool based on packet capture. These monitoring capabilities have been complemented with active device discovery for the purpose of characterising them (e.g. is this device a tablet, a TV or a PC?) and thus apply monitoring decisions (e.g. a printer should not do any bittorrent traffic, a router should not print). This talk covers passive and active techniques implemented by ntopng for discovering and classifying network devices. As well it shows how this information is used to create monitoring reports and enforce security policies. Finally the talk shows how selected devices can be both actively and passively monitored in order to implement a comprehensive monitoring solution.

Utilizing secure boot should be simple. Our current tooling is badly integrated, abstractions leaking and the code bases are not reusable. Functionality is spread between several projects and not one covers all your needs. This amounts to a confusing landscape. sbctl and go-uefi is a tool, and a low-level UEFI library, that attempts to push the secure boot landscape forward.

In this talk I'll do a short introduction of secure boot and the tooling people normally use. We will look at the different use cases each of them provide and missing functionality. Then I'll do a short demonstration of sbctl and go-uefi.

The goal is to try provoke some ideas how we can make secure boot more accessible for users. Currently the tooling assumes some familiarity with secure boot implementation details (signature lists, PK/KEK/db keys and so on) and that shouldn't be needed to have a fairly basic secure boot setup.

Compliance with Open Source and Free Software licenses remains a perennial topic of discussion among policy makers in our community. However, little attention is paid to the motivations why these licenses have specific requirements. Specifically, at least for copyleft licenses, the licenses seek to bestow specific rights and freedoms to the users who receive the software integrated into the devices they use. This panel, containing a group of industry experts, consultants, and license enforcement experts, discusses the challenges and importance of assuring downstream can actually utilize the compliance artifacts they receive with products as intended by the license.

Compliance with Open Source and Free Software licenses remains a perennial topic of discussion among policy makers in our community. However, little attention is paid to the motivations why these licenses have specific requirements. Specifically, at least for copyleft licenses, the licenses seek to bestow specific rights and freedoms to the users who receive the software integrated into the devices they use. This panel, containing a group of industry experts, consultants, and license enforcement experts, discusses the challenges and importance of assuring downstream can actually utilize the compliance artifacts they receive with products as intended by the license.

How we manage Facebook's desktop Linux fleet, and how it is positioned as a way to drive features into our server fleet.

How we manage Facebook's desktop Linux fleet, and how it is positioned as a way to drive features into our server fleet. Facebook runs CentOS on its server fleet, and offers Fedora (and soon, CentOS) as supported Linux distributions on laptops and desktops. This is a recent development - we previously recommended Ubuntu LTS as a self-supported option, but found that switching to Fedora (and officially supporting it) allows for not only reusing the infrastructure already used in the server fleet (e.g. the pipeline for creating packages) but also to serve as an integration point for driving features into CentOS. I'll also discuss how we manage the desktop fleet, and contrast it with how servers are managed.

There are dozens of domain specific languages that allow scientists to describe complex workflows. From the humble generic GNU Make to large scale platforms like Apache Airflow you would think that there is something there to satisfy everyone. All of these systems have one thing in common: they have a strong focus on partitioning large computations and scheduling work units, but when it comes to managing the software environments that are the context of each of the planned computations, they are often remarkably shy to offer opinionated solutions.

Software management and deployment often seems like an afterthought. Workflow language designers increasingly seem to be following the devops trend of resorting to opaque application bundles to satisfy application and library needs. While this strategy has some advantages it also comes with downsides that rarely seem to be weighed carefully.

We present the Guix Workflow Language --- not as a solution to the question of software deployment in HPC workflows, but as an instance of convergent evolution: growing a workflow language out of a generic reproducible software management and deployment system (GNU Guix) instead of sprucing up a workflow language with software deployment features. We hope to encourage a discussion about the current state of workflow languages in HPC: when it comes to software and distributed computations, are we approaching the peak or do we circle a local maximum?

All about MariaDB packaging in two of the most widely-used Linux distros, Debian and Ubuntu, including the strict requirements demanded by distros, and the impact on fixing bugs “upstream” in MariaDB itself.

I worked on the Go team at Google for about 10 years working on bits of everything, but primarily the standard library (net/http, etc) & its build system. In that time I wrote lots of Go, but almost primarily for Go itself. Joining a startup, I now finally get to use Go all day to build a real product (Tailscale) and it's super exciting. We use Go on the server and in 5 clients: Linux, Windows, macOS, iOS, Android.

For years now, we associate Responsive Web Design with Media Queries which adapt to the width of the device we are using. But what if we can take this one step further? Modern devices are brimful of sensors. The fun thing? There are JavaScript and CSS APIs which allow access to some of them! This talk will introduce you to some lesser known Web APIs and give examples on how you can progressively enhance your design with sensor input!

When I did some research for hackathons, I noticed on MDN Web Docs, that there are APIs for device sensors, that rarely get used.

The devicemotion and deviceorientation API might be known from Firefox OS days. But you can also use Ambient Light, Voice, Colours, Pointer devices, NFC or Bluetooth - if the device supports it.

This talk is using a Fairphone 3+ as mobile device to demonstrate some of those APIs. Part of them are available on Firefox, others on Chrome. You might need to toggle some flags to enable them. This means, it's not production ready yet - but you can build interesting demos to convince browser vendors to refine the APIs for production!

An idea might be to adjust the contrast or font to the environment you are. Or the position you are in. Or the devices which could be detected around you.

For years now, driver development has been starting earlier in the product life-cycle. Using QEMU for liberating driver developers from being bound to hardware schedules isn't new. Not so common however, is adding support for new hardware to QEMU while the spec is still being revised. The coupling of driver development and emulation development helped find spec issues early, and allowed us to submit patches for a basic driver on the day that the specification wasreleased.

This talk will discuss how we used QEMU to meet our goals, the challenges in enabling CXL 2.0 for QEMU, an review of what CXL is, an overview of the architecture and implementation, and ways in which we'd love to get help.

Raku is a programming language that spent years in development under a philosophy of torturing the language implementor developer for the sake of the language user. This results in the language and its core classes behaving in a way that it is surprising — particularly to those coming from other languages — but also intuitive. The philosophy also carries over to those who develop modules as well, particularly as certain features in Raku allow for modules to integrate themselves deeply (and often transparently) into the language.

This lecture will provide examples of ways that Raku's elements work together to create surprisingly easy and intuitive ways to do things by showcasing modules like Cro, Red, and DateTime::Timezones. It will then show how module authors have managed to recreate much of the same and provide recommendations for future module authors on how to best integrate with Raku to surprise the user through apparent mundanity. This will be done first by showing how one could recreate the gather/take structure, and then creating a more practical module that replaces the .say with localized variants while inside of a special block.

TerosHDL is an open source project focused in the development and integration of EDA tools in an IDE. It's currently based on VSCode and Atom.

The goal of TerosHDL is bringing all facilities of software code tools to the HDL development: linter, code completion, simulators management, automate documentation, snippets…

TerosHDL is an open source project focused in the development and integration of EDA tools in an IDE. It is currently based on VSCode and Atom.

The goal of TerosHDL is bringing all facilities of software code tools to the HDL development: linter, code completion, simulators management, automate documentation, snippets…

We will introduce TerosHDL VSCode with multiple features. In the new release the architecture has been completely rebuild, reduce some dependencies and clarify the code.

Some of the new features are: - Verilog/SystemVerilog support. - Linter. - Dependencies viewer. - State machine viewer. - More beautiful documentation.

Open-CE the community driven software distribution of machine learning tools that is built on standard Linux platforms across different architectures. Open-CE provides a quick easy pathway to using NVIDIA GPU technologies with tools like Tensorflow, Pytorch, XGBoost, and other related packages and dependencies.These tools are built using the standard conda environment to ensure easy access and deployment. The Open Source Lab (OSUOSL) and Center for Genome Research and Biocomputing (CGRB) partner with IBM and OpenPOWER in order to provide a download resources around Open-CE supporting both x86 and PPC64LE machines.

Open-CE the community driven software distribution of machine learning tools that is built on standard Linux platforms across different architectures. Open-CE provides a quick easy pathway to using NVIDIA GPU technologies with tools like Tensorflow, Pytorch, XGBoost, and other related packages and dependencies.These tools are built using the standard conda environment to ensure easy access and deployment. The Open Source Lab (OSUOSL) and Center for Genome Research and Biocomputing (CGRB) partner with IBM and OpenPOWER in order to provide a download resources around Open-CE supporting both x86 and PPC64LE machines.

Designers are still relatively rare in the FL/OSS space and those that have been around and active are burning out and struggling to peer support each other effectively. I see mentoring designers, new to open source software as a key way in which we can make FLOSS sustainable generally and specifically for the designer community in FLOSS.

In this session, I'll be outlining what I've observed and done as a 'mentor' in the FLOSS design space. What I've tried to do to support designers new to FLOSS in order to 'boost' our numbers actively contributing and keeping our community and OSS healthy. But there's plenty of ground unexplored here, which is why I'd like to spend half of the session actively workshopping via a shared etherpad document how we can mentor designers more sustainably withing FLOS.

What is needed by those that want mentoring? What do FLOSS projects need support with? How can mentors share resources and processes?

and likely, many more questions to collaboratively work on.

The closing keynote of 2020 covered the history of FOSDEM. Now it's your turn to share your memories. This session is an open forum for people to share 2-3 minute stories and anecdotes from their time at FOSDEM, including favourite sessions, parties, speaking experiences, and so on.

Ideas for stories might include:

• problematic journeys to the venue
• projects you saw before anyone else
• successes of projects
• people you met (or fell out with!)
• what it's like to get into the Ada dev room :)

GitLab.com has an aggressive SLA, that made us research and develop solutions to improve our performance in all directions, on one of the most important components in our architecture, the PostgreSQL relational database. During this talk, we would like to invite you to explore the details about how we improve the performance of the main PostgreSQL relational database of GitLab.com in a high demanding environment with a load between 40k to 60k transactions per sec.

We would share with you our projects, processes, and tools, and all tools being developed by our partner Postgres.ai, including the main one, Database Lab.

This talk explains how to create an Android app with "only" the Zig toolchain

This talk explains how to create an Android app with "only" the Zig toolchain. It still needs the Android SDK to create and sign the APK, but everything else is written in Zig.

The app renders the Zig logo with OpenGL ES and reacts to touch input.

Come learn about how researchers and open data initiatives are using IPFS and Filecoin to make their data resilient, accessible, and verifiable. From Starling to Qri to EDGI - many groups are pioneering the use of distributed web tools to preserve important data, empower researchers, and bring new capabilities like end-to-end verifiability or peer-to-peer data transfer to their research. Learn about best practices using these tools today, and how they're getting better in 2021.

Discussion of the most recent release of reSIProcate, how to use it and how to get involved.

This is a lightning talk about an upcoming time series/Influxdb service open source project.

MutantC is a open source and open hardware shell for a RPi form factor boards. It includes hardware keyboard, sliding display with touchscreen, battery with charging circuit, etc. This short talk will be introduction of the project, it's goals and of the v3 hardware revision.

Hardware accelerators are being increasingly integrated into today’s heterogenous computing systems to achieve improved performance. However, the resulting heterogenous hardware also increases the challenge to ensure the security of these accelerators. High-Level Synthesis (HLS) automates the creation of a register transfer level (RTL) description of a digital circuit starting from its high-level specification (e.g., C/C++/SystemC). In this talk, I would like to discuss different extensions and methodologies to High-Level Synthesis (HLS) compilers for generating secure accelerators. Precisely addressing the HLS vulnerabilities like side-channel listed in Common Weakness Enumeration (CWE) list.

Are you bored of watching the same old movies every day? Let's bring something new to the cinema. A replay of your home-made honeypot with commands played back via Asciinema.

Is this a stupid idea for audit logging? Mostly, but it's also interesting to see what users (and bots) type into your containers. In this talk, we will first show you how to quickly build your own honeypot and then talk more about the audit logging features of ContainerSSH, an open source tool that you can use for various use cases - not only for building your own honeypots but also for creating:

• Learning environments
• Web hosts
• Secure development and exploration environments

You might come up with more use cases - we're looking forward to hearing them.

This talk is aimed at people of all skill levels as we will start with the main concepts along the way. If you don't know much about containers or Kubernetes, it should still be understandable and easy to follow along. We're looking forward to answering your questions in the Q&A part of the talk.

Robotmk: How to extend the monitoring system Checkmk with checks from the user's perspective

So you think you are comprehensively monitoring your business-critical applications? Are you using Nagios, Naemon, Icinga2, Checkmk et cetera for this?

Then... let me say that, alas, you only rely on a hypothesis, because all these IT infrastructure monitoring tools have their natural limits.

Robotmk extends the monitoring capabilities of Checkmk to the application level. It integrates the results of End2End tests done with Robot Framework - which is by far the most popular and versatile tool for automated testing.

My talk first covers the basic concepts of Robot Framework and Checkmk. You will learn the added value by RobotMK and the different monitoring strategies it offers.

Robot Framework/RobotMK has been chosen as the E2E monitoring solution for the application landscape of the swiss government.

Currently, you can provision individual servers very well with foreman / katello and configure them using Ansible, Puppet or Salt. However, modern applications are composed of different services that are operated on separate servers and are connected to each other.

This presentation introduces the new plugin foreman_acd, which allows the orchestration of entire interconnected applications.

Currently, you can provision individual servers very well with foreman / katello and configure them using Ansible, Puppet or Salt. However, modern applications are composed of different services that are operated on separate servers and are connected to each other.

This presentation introduces the new plugin foreman_acd, which allows the orchestration of entire interconnected applications.

foreman_acd is a new plugin for foreman developed by ATIX AG and released as open source.

There is existing work in the public space on how to correctly construct a DRTM launch but not an equivalent amount on how to maintain the integrity of the DRTM launch over the lifecycle of a system. In particular a specific area of concern is how to correctly construct a secure upgrade for the DRTM launch that minimizes the risk of the process being corrupted. There are a few challenges that must be overcome and in this presentation these will be covered along with a novel approach that will address the challenges.

In any block-oriented, update-in-place database with log-based recovery, two kinds of page flushing are needed. Eviction flushing is necessary when all least recently used blocks are dirty (modifications exist in the buffer pool). Checkpoint flushing (writing out the oldest modified page first) allows the log checkpoint to advance, shortening the potential recovery time by logically discarding the start of the log. Any write of a persistent page must be preceded by a corresponding log write and optional doublewrite, to guarantee that crash recovery works.

We will cover some improvements in this area in MariaDB Server's version of InnoDB storage engine. We will also discuss how a database could be configured to minimize write amplification.

MariaDB 10.5 simplified page flushing and fixed bottlenecks that had originally been worked around by introducing multiple buffer pool instances and multi-threaded flushing. It turns out that a single buffer pool and page flushing thread (assisted by a log flushing thread) can still saturate most contemporary I/O subsystems. Data structures were simplified, some synchronous writes replaced with asynchronous ones, and mutex contention reduced through more use of atomic memory operations.

Grounding this virtual talk

In the times of zoom calls, virtual conferencing, and ubiquitous connectivity, I want to take some time and ground myself and this talk on the unceded[1] lands that I am living, working, and recording on as a visitor. I want to acknowledge the Coast Salish people including the səl̓ilwətaɁɬ təməxʷ (Tsleil-Waututh), Skwxwú7mesh-ulh Temíx̱w (Squamish), S’ólh Téméxw (Stó:lō), Stz'uminus, and xʷməθkʷəy̓əm (Musqueam) whose lands were stolen but have rights to these lands even today.

Abstract

Google Scholar, Web of Science, Scopus, Dimensions, Crossref, Scite.ai, ... What used to be the home turf of for-profit publishers has become a buzzing field of technological innovation. Scholarly metrics, not only limited to citations and altmetrics, come from a host of data providers using an even wider range of technologies to capture and disseminate their data. Citations come as closed or open data, using traditional text processing or AI methods by private corporations, research projects or NGOs. What is missing is a language and standard to talk about the provenance of scholarly metrics.

In this lightning talk, I will present an argument why we need to pay more attention to the processes of tracing and patterning that go into the creation of the precious data that determine our academic profiles, influence hiring and promotion decitions, and even national funding strategies. Furthmermore, I present an early prototype of Metrics in Context, a data specification for scholarly metrics implemented in Frictionless Data. Additionally, the benefits and application of Metrics in Context is presented using both traditional citation data and a selection of common altmetrics such as the number of Tweets or FB shares.

[1] "Unceded lands are territories that were never signed away by the Indigenous people who inhabited them before Europeans settled in North America. In other words, this land was stolen. (It's worth noting that territories covered by treaties also weren't necessarily ceded ⁠— in many cases, the intent of the agreements was the sharing of territory, not the relinquishing of rights.)" Source

Go 1.16 is planned to be released in February 2021 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.

Quality expectations are increasing day by day, market demand is changing rapidly and digital technologies are influencing QA practices. How do we adapt? QA plays a strategic role, it is a connection point between development and operations. DevOps can speed up the development, but what can you expect without a robust QA strategy? Continuous development and continuous delivery is impossible without a comprehensive QA strategy. How can we accelerate software delivery without sacrificing quality? Join this presentation and you will find out why QA and Ops have a complimentary mindset, how you can implement a QAOps framework and why it matters.

Breaking hardware boundaries, transcending the classic dichotomy of an OS, this is what OpenHarmony is about. Catering the needs from tiny sensors up to powerful systems, from edge to cloud.

In this presentation Stefan will address questions every FOSS developer will have, when hearing about OpenHarmony for the first time. If you are curious about the architecture, used FOSS projects, or want to know more about contribution guidelines and start picking in the code this talk would be a good start.

Stefan will talk about the multiple-kernel approach, the distributed architecture and layers. He will also explain our public development infrastructure and contribution flows.

What if millennials reinvented microkernels? How would they design them, what CPU features would they use?

Modern component-based systems, in particular microkernels, are impractical. While it is relatively easy to develop a small microkernel, it is almost impossible to build a component-based environment that can effectively reuse existing components and programs from mainstream systems. The experience of big projects, like Genode, L4Re, rump-kernel, etc. shows that it is an infinite catch-up game when developers try to reproduce POSIX environment and Linux kernel interfaces, while the mainstream systems are constantly evolving.

In this talk, I will discuss what to do with this infinite loop. I will show, that:

1. the root cause of the problem is the messaging-based API of component-based systems, which is hardly compatible with POSIX but fundamental

2. a monolithic system can be partitioned without the use of messages but requires some constraints in its design and implementation

3. Modern hardware features like Intel MPK gives new opportunities for kernel developers and allows to resolve some old systems problems.

I will present CubicleOS, a sketch of a LibOS based on Unikraft. CubicleOS does not use messages, works as automatic partitioning system, and turns monolithic Unikraft into a set of isolated components.

“We want (Exposing the Invisible) to inspire a new generation of people committed to transparency and accountability.” (Tactical Tech). Reverse-engineering consists in studying an object (or a method) in order to determine its internal functioning. Reverse-engineering consists in identifying a precise case, making a recognition, disassembling step by step and piece by piece, then understanding the mechanism; and finally reassembling the object (or the method) with a new value proposition in its operation.

We are experimentally trying to revisit the practice of reverse-engineering to explore these possible and effective contributions in the case of investigation (journalism, activism, science, art).

By: Xavier, Jess, Nuria, Clio, Laura… and more folks from Exposing The Invisible project.

In investigations, reverse engineering can be valuable as a process of learning from scratch based on deconstructing existing case studies/investigations and being able to replicate in many cases at least the more accessible parts and processes, which led to the findings and evidence exposed.

Today, organizations, events, collectives, are configuring themselves in a multidisciplinary way to tackle problems to be studied, to tackle problems to be solved. We are ourselves a group of people from different fields with different practices and skills - citizen investigators, journalists, researchers artists, technologists, etc. -- who want to demonstrate that learning to investigate can be made more accessible to local communities and individuals who may need to use such techniques in a safe, ethical and collaborative way in their own context.

Reverse engineering practices allow us to consider these paradigms from different angles, then open windows, similar to those of open hardware and free open-source software, in the fields of environment, biology, health.

Reverse-engineering as a process of deconstructing investigations, asking questions to figure out how they were made (methods, tools, resources needed, challenges, safety...) Taking something less understood or inaccessible to many and transforming it into something public -- reverse-engineering it back to the commons. The process is about finding the fundamental backbone of events, what is the part of the investigation that can be taken away.

Reverse-engineering investigations implies to be able to reconstruct and experiment with the methods and information acquired in the initial process in order to visualize what elements are indispensable to how a "system" works. It also allows one to figure out what elements could be removed, replaced with more contextual information if the method can be replicated, or "hacked" to make the "system" or method work differently in other settings.

Methodology & Major Findings:

We are experimentally trying to revisit the practice of reverse-engineering to explore these possible and effective contributions in the case of investigation (journalism, activism, science, art). We engage with different techniques, tools and methods along with the individual practices of those working at the new frontiers of investigation.

We all come from very different research and professional backgrounds, use different methodologies and techniques, investigate very different things.

From a software perspective, reverse-engineering is used for:

• industrial espionage

• cracking

• exploit creation

• security audit

• bug correction

• malware analysis

• interoperability

• scientific study

• fun.

But one question that unites us all is: what do you do when faced with a "dark box"? A finished product or event that fascinates you, but its development process, features and functions are in some way hidden from sight. It could be a network, a photograph, an environmental catastrophe, a machine - something that in order to understand or act upon, you need to be able to reconstruct how it was made.

We work with some non-negotiable constraints to this complex problem:

• intimacy & privacy concerns of the practice used and the result

• low cost or free cost access

• accessible, affordable, usable

• no domination provided to a person who has scientific or technical knowledge, understanding or skill

• reliable, transparent, and readable result.

When we share, give or receive information, during investigations or knowledge sharing sessions, we have the responsibility of explaining or demystifying a complex architectural object:

• we try to deal with a complex architectural object

• we often try to disassemble objects, even if we don’t really figure it out.

Through several experimental residencies, educational workshops, operational implementations in the field, we have gained experience and opened up a few paths for collaboration on "Reverse before any action, reverse-engineering the existing rather than producing new dark boxes". Even some use cases of Reverse-engineering during investigation.

Conclusion:

By practicing reverse-engineering on a pregnancy urine test or on a digital photo with steganography in it people regain control over the information and the technique. Similarly, the method can be applied to investigations, especially the ones built on openly available information (see such cases here: https://kit.exposingtheinvisible.org/en/index.html) and with open source tools (including OSINT investigations but not only) as well as to more complex inquiries such as follow-the-money investigations, supply chain and much more. By reverse-engineering investigations, we can help demystify and expose the insides of a process that is often assumed to be exclusive to professional investigators (journalists, law enforcement, private investigators ..). Now we want to invite other communities of practice more broadly to contribute to our experimental approach − at the crossroads between investigation, science, and open tools and technologies in order to encourage more people to use investigation methods to understand their often non-transparent environments and find safe and ethical ways to ask and address the questions and problems affecting their communities.

We also accept that our world is filled with objects from extractivist political choices supporting hyper-growth as a productive dogma.

We take our responsibility here by opening a different path in the relationship to objects, which consists as much in the mastery of knowledge and techniques as in the perspective of disassembling and improving accessibility to the existing rather than extracting in order to overproduce the invading.

Live Q/A panel with two speakers who presented works arround black box issues.

We will talk about different approaches in teaching Data Science with the Python programming language. As a case study, we will use our own experience in providing Data Science education with Python across different audiences in the Asia Pacific region and share approaches and principles that worked for us. The lecture will serve as an anchor for more conversations and discussions for adapting pedagogy that is most effective for various contexts and settings.

Programming is a fairly new human skill. Unlike natural languages and problem solving that have progressed throughout our evolution, we do not yet have neurological learning pathways dedicated for it. As such, effective pedagogies are still experimental. We will share results of experiments in curriculum and conduct that we did and highlight factors such as project-based learning, purpose-driven education, communal philosophies, applications of Agile principles, relevance to industry, and the unique circumstances of our students.

Our customary welcome.

LibreOffice was launched as a free office suite for Windows, macOS and Linux in 2010, by a large majority of OpenOffice community members. Over the years, the project has made a significant code cleaning and refactoring effort, and created a robust development infrastructure entirely based on open source software. Today, LibreOffice is available for the cloud and mobile platforms, in different flavours, optimized for community and enterprise users.

Welcoming participants to the virtual edition of the Kotlin DevRoom @ FOSDEM

Introduction to the devroom, the topics we cover…

Raku is a multi-paradigm language, that is able to do meta-programming, declarative, object-oriented programing as well as many other specific features. At 5 years, it's still a young language, but some patterns are emerging that make it quite suitable for practicing your programming chops, or embark in some side project. In this talk we will introduce some interesting programming patterns that are seen, possibly, nowhere else, from "grammaroles" through "piggybacking objects". On the other hand, for a language where TIMTOWDI, there is more than one way to do it, talking about antipatterns might look paradoxical. So let's see how we get out of this catch-22 situation.

Raku was created as a language for the next 100 years by its creator, Larry Wall, and as such it incorporates most of the paradigms tha modern language use, from a very extensive Unicode foundation, to a more classic, but still new at heart, approach to functional programming. It's this mix and match of programming paradigms that make it unique, and it's also what has provoked the emergence of certain programming patterns that solve unique problems in an interesting way. This arises as much from its design, as from its implementation, which uses Raku itself for most of it. Anyway, this talk will be about a short introduction to some Raku features, followed by a few programming patterns exemplified in Raku and in the closest you can get in other, modern languages. The main objective of the talk is to pique the curiosity about this language, which is still new, and its interesting, diverse and enthusiastic community.

The goal of the EU project FASTEN is being able to perform a more sophisticated analysis of security-vulnerability propagation, licensing compliance, and dependency risk profiles (among others) by relying on the call-level dependency network of the whole software ecosystem. We outline the purpose and structure of the project, and present some preliminary results.

The Open Source Geospatial Foundation (OSGeo) is a not-for-profit organization whose mission is to foster global adoption of open geospatial technology by being an inclusive software foundation devoted to an open philosophy and participatory community driven development.

OpenStack today is a complicated beast -- not only does it try to perform well for large clusters, but it also embraces a diverse set of possible implementations from hypervisors, storage, networking, and more. This was a deliberate tactical choice made by the OpenStack community years ago, forming a so called "Big Tent" for vendors to collaborate in to build Open Source cloud options. It made a lot of sense at the time to be honest. However, OpenStack today finds itself constrained by the large number of permutations it must support, ten years of software and backwards compatability legacy, and a decreasing investment from those same vendors that OpenStack courted so actively.

OpenStack Compute wasn't always like this though. The first public git commit had about 5,000 lines of code in it, and was surprisingly functional. What would a simpler and more opinionated IaaS compute component look like? Especially if it could take advantage of the general improvement of Open Source tooling in the last decade that OpenStack has driven? This was what I was pondering in late 2019 as I started to drift away from the OpenStack community for various reasons. Then, a series of natural disasters in Australia and globally presented me with an opportunity to cancel all my extracurricular activities and really give an experiment a go. That experiment is called Shaken Fist (as in old man shakes fist at cloud), is about the same size as the original OpenStack Compute commit, and is available at https://shakenfist.com. I'd appreciate the opportunity to discuss some of the simplifying assumptions made, what functionality is available, whether the experiment tells us anything interesting, and possible future directions.

G. Goavec-Merou & J.-M Friedt

Embedded systems are tailored to a specific task aimed at minimizing resource and energy consumption (e.g. ADi PlutoSDR). Cross-compiling benefits from powerful personal computer computational resources and user-friendly interfaces while removing the burden on the embedded board of running the compiler. GNU Radio was ported to Buildroot to provide SDR enthusiasts access to the many boards supported by this cross-compilation framework. We demonstrate its use in a graduate course project aimed at developing an embedded network analyzer.

A network analyzer for characterizing a radiofrequency device requires a radiofrequency receiver for collecting the signal that was generated to probe the response of a Device Under Test, and a matching signal source. We consider the RTL-SDR dongle as the receiver, while the Raspberry Pi processor Phase Locked Loop (PLL) has been shown to generate a radiofrequency signal in the FM band. In this demonstration, PiFM is used as a signal source. As students were not allowed to visit university during lockdown, a cost-effective solution had to be found to provide hardware to all students to complete the course at home: the solution of a Raspberry Pi4 and DVB-T dongle was selected to provide the framework of embedded radiofrequency system development. GNU Radio is cross-compiled using Buildroot to the Raspberry Pi 4, iterative tests allow for checking the functionality of each step, until a complete measurement is achieved.

Management is difficult even under the best of circumstances and managing globally-distributed teams is even more so. With the global COVID-19 pandemic and the restrictions it forced on all of us, management is nothing like the best of circumstances. With the pandemic, suddenly everyone is a remotee – even people who have no experience in working remotely, and no desire to work in such an environment. In this talk, I’ll explore how the lessons learned from navigating a globally-distributed open source community can come in to play when managing a suddenly disturbed team. I’ll examine how taking a cue from open source communities can help managers handle this new landscape with flexibility, clemency, and above all, empathy.

MySQL has now been arounds for over a quarter of a century. So what has really changed since 3.21 has become available? So how did a little programming project become the ubiquitous database? This session is a look at the many changes in the product, the company, and the people involved in MySQL.

Databases are the backbone of most modern systems, and taking some time to understand how they work is a good investment for any developer! In this article I share some non-trivial tips about database development!

Rules of thumb has been passed on from DBA to DBA for many years. Some of these rules may seem weird while others makes perfect sense. In this talk I present some of the "rules" I accumulated over the years, such as why you should always load sorted data into tables, how to make indexes invisible, and why you should always schedule long running processes in odd hours...

The ever increasing need for the ability to easily customize, reproduce and migrate applications and workflows are steadily increasing amongst the High Performance Computing (HPC)community,as non-traditional HPC software environments and applications are starting to require HPC resources to tackle “real world” scientific problems. In addition,traditional HPC software are becoming more complex and are often deployed on multiple different architectures.In this talk, we discuss the issues associated with the deployment of containerized environments on secure HPC systems and how we successfully deployed traditional and non-traditional HPC applications on a secure large scale HPC production system with HPC specific containers.

The JavaFX API's allow Java developers to create Java applications with a user interface.

The JavaFX code (API's and implementations) is developed in the OpenJFX project, under the OpenJDK umbrella.

JavaFX brings the cross-platform paradigm of Java to user interfaces (UI). A UI created with JavaFX can be rendered on different desktop or laptop systems, but also on mobile devices (iOS/Android) and embedded devices.

In this session, we will give an overview of the structure and the capabilities of JavaFX. We will also explain how the development process is organised.

We will show demos explaining how the code is integrated with IDE's, and we will discuss features that are currently on the roadmap.

During this short talk, I will introduce CADCloud an online platform tightly integrated with FreeCAD and designed to manage version tracking and user collaborations in CAD. CADCloud aims to create a reference database of 3D models generated by FreeCAD users and allow them to easily handle their lifecycle and sharing.

CADCloud is new online platform designed under an MIT licence, and hosted by the Open Compute Project. It aims to ease collaboration between CAD user around the world, share models and display them directly into a web browser. Full lifecycle management is under implementation. The platform leverage FreeCAD open file format, and is tightly integrated into it within version 0.19 through the Cloud workbench. The source code is free, open and can be self hosted.

Software emulators are wonderful tools to study old computer systems for different purpose from running legacy application to retrogaming. This talk explores the context of digital preservation triggered by on-going work in a Belgian computer museum where emulators help in rediscovering old systems, maintaining/recovering knowledge on their design and sharing the experience with the audience without stressing fragile old machines. This talk aims at exploring and somehow engaging the audience about some simple questions from that perspective: where to look for emulators (MAME/MESS, specific development, javascript ports...) ? How to select one for some usage context ? And last but not least as emulators are themselves part of history: How to make sure/contribute to the sustainability of those nice piece of software on the long run ?

The talk will not provide definitive answers to the above questions but document some guidelines gathered so far from different perspectives: usage, architecture, exchange between emulated/physical word, open/closed approaches, community aspects... based on the speaker experience as user of emulators personally and at the NAM-IP computer museum but also as software engineer experienced in evaluting software maintainability, especially open source projects. It will be illustated on a practical case from the museum: the DAI "Imagination Machine" microcomputer. The ultimate long term goal could be to build a knowledge base shared across the community developping and using emulators.

The emergence of virtualization, containers, and cloud native has resulted in tremendous advances in enabling organizations to develop new services and make them available to end users. In addition, new paradigms such as Continuous Integration (CI) and Continuous Delivery (CD) allow organisations to do this much faster than before, empowering them to go to market ahead of the competition.

Despite its many advantages, the CI/CD ecosystem has its challenges. This session will discuss issues arising from the lack of interoperability across proliferating CI/CD technologies. We will look at end user case studies, including existing integration initiatives such as that between Tekton and Jenkins X. However, these initiatives are localised to the projects involved and do not address the challenges holistically. We will highlight the necessity, and greater sustainability, of a holistic approach to interoperability in the CI/CD ecosystem and invite attendees to join community efforts.

In this talk, we’ll discuss what the Kotlin team is working on, the priorities we have, and the additions you can expect in the language.

The JVM platform is evolving, and Kotlin is keeping up with the new features as they become available. This includes the features introduced by the upcoming Project Valhalla and JVM support for sealed classes and records. In this talk, we’ll discuss how these changes affect Kotlin as a language, and how the Kotlin team finds a balance between drawing on the power of the new JVM versions, supporting the same functionality in older versions, and providing a smooth transition. We'll also talk about how you, the community, can influence the design and evolution of the language!

Live stream showing working applications and trying those the audience suggests to try. Some live installation with USB stick as this is new for ROS to work. Commented video of ROS booting on a XBox.

Observability is not a new idea, it first originated in control theory. In control theory observability is defined as "A measure of how well internal states of a system can be inferred from knowledge of its external outputs" We software folks borrowed the term and now define it as the property of any system that allows us to understand what is going on with them, monitor what they are doing and get the information we need to operate & troubleshoot. In this talk, I am going to give an introduction to observability and also talk about how someone can contribute in this space.

Presentation of the new features in sparselizard 202012. They include adaptive mesh refinement, interpolation order adaptivity (hpFEM), time-adaptivity, speedups, syntax optimization, link to gmsh, move to cmake and a large number of added functions.

Collabora Online (COOL) is a LibreOffice-based online office suite with collaborative editing. Time-to-start-hacking COOL has been lowered from ~a day to ~10 minutes thanks to integration with GitPod, a dev environment in the cloud, on its GitHub repo.

We will try to share the story on and discuss these topics: - What was it like in the past - The search for ways to lower the barrier - Cloud dev environments - Setting up the repo for GitPod integration - Adapting the infra/CI for faster builds in the cloud (and its nice side effects) - Quick start on hacking COOL in the cloud - Some numbers - Can it be applied also to core (LibreOffice) repo? How?

OSGeoLive is a self-contained bootable DVD, USB thumb drive or Virtual Machine based on Lubuntu, that allows you to try a wide variety of open source geospatial software without installing anything. It is composed entirely of free software, allowing it to be freely distributed, duplicated and passed around. It provides pre-configured applications for a range of geospatial use cases, including storage, publishing, viewing, analysis and manipulation of data. It also contains sample datasets and documentation. You will get to know the project and what you can learn and have a look behind the scenes.

Jsonb is popular data type in postgres and there is demand from users to improve its performance. In particular, we want to optimise a typical pattern of using jsonb as a storage for relatively short metadata and big blobs, which is currently highly inefficient. We will discuss several approaches to improve jsonb and present results of experiments.

Recently Google published a paper on their monitoring system Monarch, which happened to have similar design choices to the existing CNCF Incubated project: Thanos! During this talk, two of Thanos maintainers will explain why Thanos could be claimed as an unintentional open source evolution of Google Monitoring Systems like Monarch.

Google is known for building massive, global scale solutions. While organizations rarely have a similar scale, we can learn from those solutions while developing in Open Source. We all see the successes of Kubernetes which was inspired by Google Borg, and Prometheus based on Google Borgmon.

Recently Google published a paper on their monitoring system Monarch, which happened to have similar design choices to the existing CNCF Incubated project: Thanos!

During this talk, two of Thanos maintainers will explain why Thanos could be claimed as an unintentional open source evolution of Google Monitoring Systems like Monarch. By following this comparison, the audience will learn the general pattern of using and scaling the Thanos system. This talk will also reveal the exciting direction of the project including the map-reduce pushdown for PromQL queries for massive cost reduction (don’t tell anyone!)

Learn why the community is so passionate about moving Thanos and Prometheus projects forward!

Three phrases keep popping up when talking about modern workflows and development and deployment techniques; CD, GitOps, and progressive delivery.

Three phrases keep popping up when talking about modern workflows and development and deployment techniques. We have continuous delivery to automate the complete lifecycle of applications from a commit to a Git repository, all the way until a release is deployable to production. Then we have GitOps to define the desired states of our environments and let the machines handle the converge the actual into the desired state. Finally, there is a lot of focus on different deployment strategies grouped under progressive delivery. They are all focused on the iterative release of features to make the process safe, prevent downtime, and reduce the blast radius of potential issues.

While those three practices and the tooling behind those are focusing on specific areas, the "real" benefits are obtained when they are combined. Nevertheless, many did not yet reach that stage. Each of those practices alone can be daunting and, frankly, scary. Yet, we should go a step further and explore how to combine them together and see the benefits such a solution might provide.

Through a hands-on demo, we will combine Argo CD as a tool of choice for applying GitOps, Argo Rollouts for progressive delivery, and Argo Workflows for continuous delivery pipelines that will tie those two together with the rest of the steps needed in the lifecycle of our applications. If we are successful, we might remove humans from all the actions coming after pushing changes to Git repositories.

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 implementation 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 runtime checks.

The talk will explain Fuzion's motivation and present its main concepts, feature declarations and feature calls. It will not go into details of the syntax, but present Fuzion's approach to immutability, memory management and type inference.

Introduction

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 for nesting of 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 for all the rest.

Fuzion Feature Declarations

A Fuzion feature is 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 any Fuzion system. 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 declares 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 he declaration of choice types or functions 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.

Inheritance may result in conflicts, e.g. if two features with the same name 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.

Contract

A feature may declare a contract that specifies what the features does and under which conditions the feature may be called. This will be handled in more detail below in the section Design by Contract.

An implementaton

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 s struct or record in other languages:

point(x, y i32) is # empty
p1 := point(3, 4)
stdout.println("p1.x is " + p1.x)    # will print "p1.x is 3"
stdout.println("p1.y is " + p1.y)    # will print "p1.y is 4"

The next example show a feature base that provides an innver 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)
stdout.println(b1.plus(23))    # will print "53"
stdout.println(b2.plus(23))    # will print "123"

Features and Types

A feature declaration implicitly declares a type of its instances. In the example above, the feature declaration

point(x, y i32) is

declares the type point that can be used to declare a feature of field type, so we could, e.g., declare a new feature that takes an argument of type point:

draw(p point) is
  drawPixel(p.x, p.y)