In an era driven by data and digital collaboration, access to foundational research skills is increasingly essential—yet research capacity remains deeply unequal across the globe. For instance, Africa has only 20 health researchers per million people, compared to 246 per million in Europe, according to the World Health Organization’s Global Observatory on Health Research and Development. This stark disparity highlights the urgent need for accessible, inclusive research training to bridge the gap in global knowledge production.

Pre-Seeds (Research 101) is an open-source, community-driven initiative inspired by OLS’s capacity-building programs, such as Open Seeds and Nebula. The course is designed to break down barriers to research literacy and amplify underrepresented voices in open science. It is targeted at research enthusiasts, citizen scientists, early-career researchers, and Research Software Engineers (RSEs) from non-academic backgrounds.

Currently in its early stages, Pre-seeds aims to create a flexible, modular curriculum covering key aspects of research often taken for granted, such as research design, ethical considerations, data management, and collaborative practices. The project leverages open tools like GitHub to promote collaboration, transparency, and reproducibility, inviting broad participation across disciplines and experience levels.

This session will present Pre-Seeds as a growing, collaborative effort to build an inclusive research ecosystem. By showcasing the project’s vision and its potential real-world applications, we’ll open the floor to feedback and invite attendees to join us in shaping this initiative—whether through expertise, funding, or community engagement—to co-create a more diverse and accessible future for open science.

I started with the question "how can I make managing DNS more user friendly for a customer" and the discovery of a small plugin for NetBox and ended up as the maintainer of a moderately complex and increasingly powerful DNS management tool.

The talk will touch the core features of the plugin: * Validation of names and values * Automatic generation of NS, SOA and PTR records * Zone and record templates * Handling of RFC2317 zones * Automatic generation of DNS address records for IPAM IP addresses

Our exploratory quest of previously uncharted territory of real-time TCP/TLS media over SIP RFC4145 (hey don't confuse it with TCP as a SIP transport!) and all the fun and possibly profit that can be had from it potentially. As part of the presentation I would announce the SIP Proxima project implementing this functionality and do a demo of various application protocols (e.g. postgresql, mysql, rrdcache, thrift, https etc) operating over it.

A dual-MAX2771 radiofrequency frontend fitted on a FX2LP parallel to USB interface is presented as an update to Tomoji Takasu's PocketSDR. Having understood the underlying operating principles of the FX2LP configured through its 8051 microcontroller core using the opensource sdcc compiler, we configure the MAX2771s to collect samples up to 44 MS/s in the L-band ranging from 1 to 2 GHz. We first demonstrate proper operation by collecting and decoding Iridium messages using gr-iridium, despite the 2 or 3-bit resolution of the IQ ADCs, before demonstrating post-processing and real time processing of GNSS data. Both real time data collection, processing and streaming using GNU Radio and GNSS signal decoding using gnss-sdr are demonstrated. Tomoji Takasu's PocketSDR software provides invaluable insight and our contribution is porting the firmware to sdcc to get rid of any proprietary tool for developing the PocketSDR-like board.

The coherent multi-receiver architecture allows for processing the same L-band with two antennas for Controlled Radiation Pattern Antenna (CRPA) processing and detecting spoofing by inconsistent direction of arrival ; or processing two bands (e.g. L1/L5 or L1/L2) simultaneously.

See https://github.com/jmfriedt/max2771_fx2lp/: the subject of this presentation was the core project of the opensource tools for embedded systems development ELISE Master teaching at University of Franche-Comté is Besançon, France.

In early 2024, Tesla introduced strict API rate limits, reducing the number of commands to just 50 per day. This disrupted my smart charging automations, which were sending thousands of commands on a daily basis for tasks like solar charging and load balancing. To overcome this, I re-implemented Tesla's vehicle protocol in C++ for the ESP32 microcontroller, enabling local control of my Tesla by acting as a BLE (Bluetooth Low Energy) vehicle key.

In this talk, I'll give an overview of Tesla's vehicle protocol, dive into BLE communication using an ESP32, and show practical ESPHome implementations for common vehicle controls. The result is a cheap, open-source solution operating entirely locally with sub-second response times - no internet or API tokens required.

Wireless displays are something most of us use, but in a fragmented and proprietary landscape. We propose a new approach to virtual screen sharing between Linux mobile and desktop devices.

This solution uses a combination of video pipelines optimized for ARM and x86 hardware, D-Bus, and low-latency UDP streaming to create virtual “second monitors” and stream the desktop between peer devices. It is optimized to be usable even on low-power hardware such as the Librem 5, allowing us to repurpose older devices as secondary network monitors without proprietary tools. [2]

In this talk, I will try to demystify some of the technicalities required for implementing efficient wireless desktop streaming using GStreamer, PipeWire, and D-Bus. To this end, we will explore how to build network video pipelines from scratch, with a focus on minimizing latency and making good use of hardware acceleration. Finally, we will present the Mirror Hall app, an experimental GTK4 app that encapsulates the above concepts. [2]

Links: 1. https://notes.nokun.eu/post/2024-09-22-mirrorhall/ 2. https://gitlab.com/nokun/mirrorhall

Endpoint Detection and Response (EDR) solutions continuously monitor the events occurring on an endpoint, create detailed process timelines, and analyse these data, to reveal suspicious patterns that could indicate threats such as ransomware. To create these detailed timelines, EDR solutions collect a variety of information about each process running on the endpoint, such as timestamp, PID, process name, path, command line, etc. On Linux systems, this is often done using the proc filesystem provided by the operating system, which provides rich information for each process currently running on the system. However, if a process is short-lived and exits quickly, the proc filesystem entries for it get cleared out before the EDR solution can read them, leading to incomplete timelines. To take a simple example, suppose a malicious actor runs a script that downloads a binary from the network and then executes it. This downloaded binary quickly spawns a bunch of long-running malicious processes and exits itself. If EDR solution is unable to extract the complete process information about the execution of the downloaded binary from proc filesystem (being a short-lived process), it'll miss details about the creator of the malicious process in the system. Hence, EDR solution will have visibility gaps about the downloaded binary required for Security Threat Analysis. We propose a solution to address the gaps by attaching extended Berkeley Packet Filter (eBPF) programs dynamically to the Linux kernel system calls (such as fork, exec and exit) and extracting all the required information directly from the kernel hooks using BPF Type Format (BTF). These hooks use fundamental task structure in kernel representing a process or thread to extract variety of information about the process. Our proof of concept shows that eBPF-based process data extraction provides process timelines with near 100% reliability, compared to proc filesystem-based approaches which have a reliability of only around 83% for short lived processes.

Join us as we build a ChatGPT client, from scratch, using Swift OpenAPI Generator. We’ll take advantage of Swift OpenAPI’s pluggable HTTP transports to reuse the same generated client to make upstream calls from a Linux server, providing end-to-end streaming, backed by async sequences, without buffering upstream responses.

In this session you’ll learn how to:

• Generate a type-safe ChatGPT macOS client and use URLSession OpenAPI transport.
• Stream LLM responses using Server Sent Events (SSE).
• Bootstrap a Linux proxy server using the Vapor OpenAPI transport.
• Use the same generated ChatGPT client within the proxy by switching to the AsyncHTTPClient transport.
• Efficiently transform responses from SSE to JSON Lines, maintaining end-to-end streaming.

Timeline algorithms should be useful for people, not for companies. Their quality should not be evaluated in terms of how much more time people spend on a platform, but rather in terms of how well they serve their users’ purposes. Objectives might differ, from delving deeper into a topic to connecting with like-minded communities, solving a problem or just passing time until the bus arrives. How these objectives are reached might differ too, e.g. while respecting instances’ bandwidth, one’s own as well as others’ privacy, algorithm trustworthiness and software licenses. This talk introduces an approach to personal, local timeline algorithms that people can either run out-of-the-box or customize. The approach relies on a stack which makes use of Mastodon.py to get recent timeline data, llamafile to calculate post embeddings locally, and marimo to provide a UI that runs in one’s own browser. Using this stack, we will show how to perform search, clustering, and recommendation of posts from the fediverse without any of them leaving your computer.

Kubernetes is commonly run on cloud, and even more commonly on its managed form. However, self-managing k8s on your own metal is also fun!

In this talk I will walk through some of the challenges I've found while doing this for the last three years, and share what are the tools I've used to conquer them, such as kubeadm, cilium, metallb, stateless-dns (external-dns + powerdns), and others.

Packet Filtering in BSD could be seen from several angles. There are quite a number of packet filters in the BSDs. some Implemented in the kernel, some in the user space. In this talk, we will go through a particular NetBSD packet filter, NPF, evaluate its numerous advantages and assess critical performances and share its directions going forward.

The valgrind error manager makes it easy for valgrind tools to report issues that can include execution backtraces for multiple events, integrate with gdb, generate xml reports and lets users suppress specific issues. The valgrind error manager contains a fast unwinder which can be used to detect "equivalent" issues.

For valgrind 3.23.0 we introduced "core errors" which are tool independent and can be used to report on core events for resources that are explicitly created and destroyed. We used this to add errors when using file descriptors that can be reported by any valgrind tool by using --track-fds=yes. This allows reporting on bad use of file descriptors, file descriptors that are double closed, used after closing, and file descriptors that "leak". Because these are "normal" valgrind errors all these events can be reported in the xml output, suppressed by the user, intercepted by gdb and integrated in CI runs with --error-exitcode.

For Valgrind 3.24.0 we added bad file descriptor usage errors.

Despite memory isolation being used for decades now; a typical contemporary low-power IoT embedded system does not use this technique. One of reasons might be that in virtually all available systems memory isolation is an afterthought. We proposed, designed and implemented CMRX real-time operating system targeted towards devices without MMU which takes memory isolation as non-negotiable feature.

Achieving usable memory isolation on such constrained hardware has its challenges and there are compromises to be made. In this talk I will outline high-level design decisions and overall system design of the CMRX RTOS. Why micro-kernel design is suitable in this situation, what advantages does it bring? I will tackle benefits and potential drawbacks of proposed architecture and finally cybersecurity point of view will be discussed.

Open science is at the forefront of transformative progress in research, yet its advancement is often stymied by fragmented infrastructure, limited interoperability, and inadequate crediting of research outputs. These challenges hinder the accessibility, reproducibility, and verification of research, slowing the pace of and trust in discovery and innovation.

This talk introduces the Scientific Coordination Infrastructure and Operating Systems Collaborative (SciOS) as a solution-oriented 501c3 (US non-profit) initiative to bridge the gap between researchers and technologists. SciOS facilitates the ongoing development of open, scalable, and interoperable infrastructure that empower the scientific community.

This talk will explore the rapid development of solutions possible when researchers and technologies exist in the same space.

Key Technologies and Innovations:

• dPIDs and CODEX:
  Decentralized Persistent Identifiers (dPIDs) generate cryptographically unique, permanent identifiers for research artifacts. Combined with CODEX, an open system for managing versionable research objects, dPIDs ensure trust, reproducibility, and accessibility in scientific outputs.

• Journal Creation Software:
  SciOS supports tools that enable decentralized, community-driven curation-based journals. These platforms exist on an open repository of human knowledge accessible to everyone, and empower scientific communities to elevate from that repository research that aligns with their values, quality definitions, and scope with minimal friction.

• DeSci Publish:
  Operating on CODEX, DeSci Publish redefines scientific publishing by allowing researchers to share data, code, manuscripts, and more as versionable objects.

• Granular Citation Systems:
  Through dPIDs, CODEX, and decentralized platforms, SciOS enables journals to credit contributions ranging from datasets and software to peer review and editorial work.

• Automating Metadata Creation:
  In partnership with DeSci Labs and Discourse Graphs, SciOS automates the generation of metadata and discourse nodes. This initiative creates a map of research claims and evidence, allowing researchers to evaluate the relevance of prior work at a granular level.

• Research Assessment Tools:
  Collaborating with the CoARA ERIP working group, SciOS is developing tools that combine human expertise with AI to evaluate modular research objects. These tools enable clear, reliable assessments tailored for rapid response to research outputs.

• Open Source Permanent Versionable Containers and Attestation Platform:
  SciOS supports this platform to create immutable repositories for software tools. It provides versionable digital containers enriched by community validations, enabling researchers and engineers to track, validate, and determine software impact across domains.

• Institute of Open Science Practices (IOSP):
  IOSP fosters collaboration between researchers and technologists, guiding the adoption of innovative infrastructure. It facilitates workshops and conferences powered by novel tools, enabling open science practices throughout the research lifecycle.

Join us to explore how SciOS’s collaborative efforts and cutting-edge tools are transforming open science. Discover how decentralized infrastructure, automated metadata, and innovative publishing systems can break barriers, foster trust, and accelerate discovery across disciplines. Together, we can build the open science infrastructure the world needs.

With the introduction of the EU Cyber Resilience Act a number of interesting questions are raised. This talk focus on the EU CRA and discuss some of the implication when applied to Free and Open Source Software licensed under Copyleft licenses such as the GPL.

The EU CRA introduces, under some circumstances, an obligation to contribute upstream if there are vulnerabilities, what will best practices be to manage this obligation in permissively licensed project respective in Copyleft licensed projects, how will this impact customer agreements, R&D collaborations and similar.

MicroPython is a tiny implementation of Python, designed for very constrained environments such as microcontrollers and embedded devices. It can run on devices with as little as 64 kB of RAM and 256 kB of FLASH. Over the last 10 years, MicroPython has become a productive development environment and mature platform for firmware development. It has been used in many applications - and has been deployed on everything from smartwatches to medical devices and satellites.

There are many features of MicroPython that make it an attractive way of developing firmware, such as: the built-in file systems, first-class package management, built-in communication over WiFi/Ethernet/BLE/USB/etc, interactive programming via REPL, automated testing on PC and device. We will introduce these features briefly, and then discuss our favorite feature: the support for C modules, and how it enables building sensor systems that are both computationally efficient and fast to develop.

Transition from open collaboration to customized control with Wikibase, a self-hosted platform designed for tailored data management. While Wikidata provides a robust, open, multilingual, and collaborative environment, it may not fully address the specific needs of personal or institutional data. Wikibase empowers you to structure and manage your information on your own infrastructure, combining the strengths of Wikidata with the flexibility of a self-hosted solution. By seamlessly integrating global entities, leveraging existing translations, and aligning with linked open databases, including Wikidata, Wikibase enables you to build a connected and enriched data ecosystem. Discover how Wikibase bridges collaboration and control, offering independence while staying interconnected within the open data landscape.

References: 1. Wikidata 2. Wikibase 3. Wikibase on GitHub 4. Wikibase Cloud 5. The Linked Open Data Cloud

This session will give you an overview of the current status of the CJK input system in Wayland.

We will start with an overview of how to input CJK languages, focusing on the Korean writing system(한글, Hangul).

Next, we'll look at the different input protocols in Wayland and how they work. I will also show what still needs to be done to improve the CJK input system in Wayland.

Managing the data deluge (exabytes) generated by worldwide large-scale scientific collaborations is a challenge.

The Rucio Data Management platform is an open-source framework written in Python engineered to orchestrate the storage, distribution, and management of massive data volumes across a globally distributed and heterogeneous storage infrastructure.

Rucio meets the requirements of high-energy physics, astrophysics, genomics, and beyond, pioneering new ways to facilitate research at the exabyte-scale and is used by major scientific experiments: the ATLAS and CMS experiments at CERN, Square Kilometer Array Observatory, Cherenkov Telescope Array, KM3NET and Belle II to name a few.

This presentation introduces the Rucio project and the technology behind it.

This talk will include a presentation about changes that are happening to email address syntax, as well as recent developments to Unicode email addresses. In addition, IETF and W3C email syntax rules, which are primarily compatible, will be discussed. Both organizations have proposed updates to extend the rules (i.e., via an IETF draft and W3C Github pull request). There'll be brief information regarding the proposed changes, address validation and web browsers/forms and of course implementation progress

Postmarks is a piece of Fediverse software meant to provide a social bookmarking platform along the lines of De.licio.us and its successors. Despite the published ActivityPub spec having in mind a variety of verbs and nouns, and the ability to create "extensions", most software that I found while looking around in the early days of Postmarks looked to be recreating "timeline-based social media", where the primary activity took place on the platform itself and involved reading content from other users and generating more content of the same expectations. This is not to say there are none, but how much they expect to integrate with platforms like Mastodon varies.

When thinking about what that meant for Postmarks, deciding how interoperability should work presents some interesting questions. There are opportunities in interoperability: even if you're not the kind of person to whom the activity of bookmarking and curating links is interesting, you may know someone who does whose work you want to follow, which you can then do from Mastodon. On the flipside, you may be a researcher who spends time collecting information and values the viewpoints of others but doesn't want to take part in a product designed like a traditional social media site. There are also drawbacks: as an individual maintainer with a handful of contributors to my platform, integrating with existing platforms that are already large enough to have abusers, scrapers, and other bad actors opens me up to those problems much sooner than it would if I were creating my own siloed ecosystem. Less urgently, there are new software design questions raised by the functionality of the platforms interacting. How do I make Postmarks content appear on platforms like Mastodon? As I build out the ability to find bookmarkable content from the Fediverse within Postmarks, how do I do that in a way that keeps in mind the ideals of Postmarks rather than the spaces it's connecting to? What choices have been made that add extra requirements on top of the ActivityPub spec in order to make interoperability smooth and consistent? In designing a piece of ActivityPub software designed to have one small "instance" that hosts the activity of one "actor", I also found myself stumbling across design decisions made in the creation of large platforms like Mastodon and Pixelfed that left me with questions about the ethics of designing software that can interact with those places. How do I prevent my software from becoming a tool for bad actors targeting those places?

By looking at the design problems introduced within the early development of Postmarks and an analysis of other ActivityPub platforms that have either dealt with, are still working on, or have not faced these questions, we can create space for discussing what a future looks like where a broad variety of ActivityPub software is out on the internet speaking the same protocol but choosing when and how they interact in a way that cultivates communication and works to minimize harm.

In today’s software development landscape, products are often an intricate blend of in-house code and open-source third-party dependencies. While many organizations have robust procedures to secure their own codebase, the strategies to safeguard against vulnerabilities in open-source components are not as well-developed.

In this session, we will navigate the complexities of implementing an effective process to manage vulnerabilities within open-source dependencies. Our discussion will cover key considerations for evaluating software composition analysis tools and detail the steps necessary for a successful tool rollout. We will delve into effective strategies for triaging findings and shifting from a reactive to a proactive security posture.

You will leave the session equipped with a foundational but adaptable process, ready to enhance the security of your products that depend on open-source dependencies.

What if gaming didn’t require a powerful computer or even a traditional console? In this talk, we’ll explore how with TinyGo you can create interactive games and experiences directly on microcontrollers and embedded hardware. From LED matrix games to unconventional input methods and minimalist sound effects, we’ll demonstrate how to harness the simplicity of TinyGo for innovative hardware projects.

Whether you're a seasoned Go developer curious about embedded systems or a hardware tinkerer looking for new ways to code your ideas, join us for a fun, hands-on dive into the possibilities of TinyGo-powered gaming, no computer required!

Project Leyden was created in May 2022 with the goal of improving footprint, startup time and time to peak performance of Java applications. Initially, a variety of different approaches were under consideration and the first proposed solutions only started to clarify around 18 months ago. An early preview of the 'premain' solution, prototyped by Oracle, was presented at the August 2023 JVM Language Summit. It has been under very active development since then, with a team that includes developers from Oracle, Red Hat, Microsoft, Amazon and Google, and has already delivered improvements to JDK and application startup time in OpenJDK 24 via JEP 483. The plan is for the project to deliver a series of JEPs that improve performance step by step rather than wait for a complete, shrink-wrapped solution and the Leyden team is already working on the next set of enhancements. In this talk we will explain what was delivered in JEP 483 and how it works to improve startup, then go on to describe what other features are in the pipeline. We will also touch upon some of the barriers we currently face to improving performance and ideas we are exploring to resolve them.

In this talk, we will walk through different scalability challenges various modern CI setups encounter today: caching, distributed computing, reproducibility, telemetry... and how advanced build tools such as Bazel, Buck2, Pants,... addressed them at scale at big enterprises. We will then drill down into the common Remote Build Execution protocol that these tools all have in common. Finally, we shall reflect upon the current state of the build tool ecosystem and highlight key areas to improve upon.

phosh is a graphical shell for mobile devices built using GNOME technologies. With more than 80 releases in about 6 years under it's belt it is both time to celebrate and glimpse into what the future will bring!

The WebKit WPE and GTK ports are aiming to leverage GstWebRTC as their WebRTC backend. Over the years we made progress towards this goal both in WebKit and in GStreamer. During this talk we will present the current integration status of GstWebRTC in WebKit and the plans we have for the coming months.

Vitess, a CNCF-graduated, open-source, MySQL-compatible database, is designed for massive scalability and cloud-native deployments. As one of the most robust solutions for managing large-scale database workloads, Vitess on Kubernetes powers some of the largest systems in the world.

Modern data teams face a growing challenge: scaling databases dynamically to handle surges, such as holiday sales or viral trends. For many, vertical scaling has reached its limits, leaving fundamental architectural changes as the only option. Vitess, with its built-in horizontal sharding capabilities, provides a seamless path for organizations to scale beyond the constraints of legacy MySQL or Aurora clusters. This talk explores how Vitess enables smooth migrations from Aurora and MySQL into Kubernetes clusters with near-zero downtime. We will begin with an overview of Vitess’ architecture, highlighting horizontal sharding and its advantages for scaling. Next, we will dive into the powerful workflows Vitess provides for data import and live production migrations, emphasizing their safety, efficiency, and reversibility—even for massive datasets.

To ground these concepts, we will share real-world examples of successful migrations from web-scale Aurora and legacy MySQL databases, including performance metrics, data sizes, and challenges encountered. Attendees will gain practical insights and a clear blueprint for transitioning large-scale database systems to Vitess, unlocking unprecedented scalability and operational agility.

PostgreSQL's extensibility is legendary, and a revolution is brewing: Rust is emerging as the new gold standard for writing robust, performant database extensions, with the promise to make them safer, faster, and more maintainable than ever before.

In this hands-on session, we'll discover the PGRX framework through 4 practical examples showcasing:

• Memory safety guarantees
• A fully managed development environment
• Access to Rust's vast ecosystem of libraries
• Seamless PostgreSQL integration

Based on my experience rewriting the PostgreSQL Anonymizer extension from C to Rust, I'll share the lessons learned along the way.

Whether you're a seasoned C developer, a rustacean, or a new to PostgreSQL extension writing, this talk will equip you with the knowledge to leverage Rust's powerful features in your next database projects.

Large language models (LLMs) may represent a shift in how open source communities support their members. This talk explores the nuanced and evolving role of LLMs in fostering community engagement. Specialized companies offer tailoring of LLM and automation of responses to technical questions. We will explore a range of adoption options from cautious, opt-in approaches confined to specific channels to fully embracing LLMs for first-line support across forums. These strategies raise questions like:

• Could automation stifle organic, person-to-person connections in communities, or can it expedite learning and enable meaningful contributions from newcomers?
• How do LLMs reshape the balance between in-person and digital interactions, and what does this mean for the future of community building?
• Are LLMs the natural evolution of IRC-era bots, or will they alter the patterns of open source collaboration?

We’ll look at case studies from real communities. Attendees will get actionable insights for navigating the adoption of LLMs in their own communities, striking a balance between automation and authentic human connection.

As RISC-V reaches maturity, we look at how RISC-V designs are performing. We look at how performance has improved over the years and how performance compares to other cores, particularly those from Arm. We'll explore the impact of different extensions and compilers on performance of compiled code. We'll also look at how useful measuring performance using models is for predicting the performance of real silicon.

Throughout we will use mostly the Embench benchmark suites, with some use of SPEC CPU for application class cores. We will present the first results from the new Embench IoT version 2.0 test suite.

Finally we will show how combining accurate benchmarking with simple machine learning can yield additional performance of compiled software. This will be illustrated with the OpenHW CV32E40Pv2, where we were able to improve benchmarked code density by 7% in just 24 hours.

I've created an rDNS map, available at https://reversedns.space/, and I want to tell you how.

It was not hard to do, but there was a lot of unusual and amusing stuff in the process.

I'll give an update on the latest development from kprobe and uprobe world including new session feature and uprobe performance enhancements that already got merged and those that are still being worked on.

In this talk we briefly present Sxmo and share the current state of things. Sxmo is a hacker-friendly mobile UI for Linux phones, like those running on postmarketOS. Our approach differs from what the mobile user is accustomed too, but one that will appeal to those drawn to software minimalism and those with an urge to tweak and control their system to the max! We tie together various FOSS components, some interchangeable, via POSIX shell scripts. Through our hook system users can customize these to a large extent.

• Do you want to SSH into your phone and have all functionality available remotely?
• Do you like the idea of running a tiling window manager (sway, dwm) on your phone just like on your desktop?
• Do feel nostalgia for operating your phone with menus (dmenu, bemenu, wofi) and hardware buttons?
• Do you want to be the one in control of our own device and data, rather than be on the leash of big tech companies?

Then this talk may be interesting for you!

Did you know that you can write a cloud-native service in Swift and publish it in a container image, ready to run on any standard container-based cloud infrastructure, all using just the Swift compiler and its build system?

In this talk we'll see how Swift's strong multi-platform support and highly extensible package manager can take care of the whole process for you, allowing you to build your application, package it and upload it in one efficient step:

• Swift SDKs extend your native Swift compiler, giving it the ability to cross-compile and produce Linux executables directly on macOS.
• swift-container-plugin extends Swift Package Manager, giving it the ability to construct a container image and publish it to a container registry.

We'll see these tools in action and peek behind the scenes to learn how they actually work. Along the way we'll answer questions such as:

• How can we build Linux binaries on macOS?
• Can we build our own custom Swift SDKs?
• What actually goes on when we build, push and pull container images?
• How can we build a container image from scratch, just using Swift?

Open Source Business Intelligence (BI) is here, and here to win!

In this talk, we'll take a look at Apache Superset, the Apache Software Foundation (ASF)'s #1 project by GitHub stars, and learn about the features and flexibility that make it the leading tool for data visualization in the open-source data stack. We'll talk about what it does, how it works, and how it's built, highlighting its key workflows and philosophies.

In this talk I will share some details on the path towards the recently obtained Security (EAL4+, German GEHEIM) and Safety (ISO26262 ASIL-B, SIL-2) certifications that have been achieved for the L4Re Operating System Framework. I will show some details on where generic software development, operating systems, and third-party code clash with the expectations of the safety norms. I will also shed some light on the challenges we face in maintaining these certifications while staying true to the open source nature of the system with contributions form a multitude of actors from various fields. I will conclude with an outlook of the things to come and how we want to ensure that open source microkernel-based operating systems can be a vital cornerstone to safe & secure systems.

Although it was invented decades before the term "safe language", COBOL was created to meet that very need. At the time in that environment, the predominate alternatives were FORTRAN, and assembly language.

Safety means different things to different people and in different contexts. By some definition, no language is safe. By others, COBOL may be considered among the safest.

Kamailio is one of the most widely used open source SIP servers for large VoIP and real-time communication platforms. The talk will give an overview of the key topics of the newly released version 6.0, describing the improvements in the UDP worker architecture, asynchronous processing, the new build system and other important changes. The presentation is aimed at people who are interested in developing high-performance VoIP platforms, developers who want to extend or improve Kamailio, and operations experts who run Kamailio infrastructures.

Cypht is an awesome Free/Libre/Open Source webmail aggregator written in PHP and JavaScript. Tiki is the Free/Libre/Open Source Web Application with the most built-in features, obviously including a webmail. Cypht within Tiki expands on the collaboration possibilities.

Email handling (reading, replying and archiving) should be part of a larger collaborative workflow. Instead of one gigantic mail store, we should have a number of smaller ones that make sense to one's workflow (ex.: around projects, tasks, clients, etc.) and that can easily be shared and prioritized.

Get to know the Aparoksha project. Write your app once and deliver a truly native look and feel across the major desktop platforms, all with a declarative framework!

The most mature part of this project is the Adwaita for Swift package, allowing the creation of native GNOME apps.

In this presentation, I'll introduce the core principles of Aparoksha, showcase its current capabilities, and share my vision for its future.