As a city long renowned as a center for education, particularly in the sciences and engineering, it makes perfect sense that Edinburgh, Scotland will serve as host city for this year’s Open Source Summit Europe. More than 2,000 will congregate at the Edinburgh International Conference Centre from October 22-24 for Open Source Summit Europe, the leading conference for developers, architects and open source community and industry leaders to come together in collaboration, share information and learn about the latest technologies and innovative open solutions.

Once again, VMware is proud to be a Gold sponsor of Open Source Summit Europe and help lead the charge to gather the open source ecosystem under one roof for maximum cross-pollination between those driving the future of technology. With 65% of companies utilizing open source software, it’s important events like OSSEU take place now more than ever.  Everything from serverless to edge computing to AI will be on the table, and VMware is excited to be a part of this conversation with quite a few sessions and panel discussions. See what all we’ll be up to at Open Source Summit Europe this year:

With a variety of embedded systems making IoT, Linux is proving to be a significant contributor here. But many IoT devices are deployed in critical infrastructures like energy generation, avionic, automotive, etc., where everything needs to be certified according to different specifications. That said, we need to explore making Linux itself certified. This presentation will review how to build a customized Linux distribution to achieve this.

Serverless functions are about iterating faster, but users are having to create their own complex solutions to get functions into production. This talk will introduce OpenFaaS Cloud, a portable CI/CD pipeline that enables a GitOps experience as originally popularized by Heroku. OpenFaaS Cloud focuses on usability, with a built-in dashboard and security using CNI NetworkPolicy to isolate functions, CertManager for HTTPS and Bitnami SealedSecrets to enable any secret to be stored in a public GitHub repo. You can use your own cluster, a managed Kubernetes service or the free community-supported cluster.

This talk will introduce OSSEU audiences to kubeadm, a tool for Kubernetes cluster deployment and administration. It will provide a brief introduction and history of the tool, as well as a review of the project’s features, design and status. Stick around until the end for a demo of kubeadm, too.

Virtualization technologies have already been deployed in embedded systems but in many use scenarios, applications/services should be responsive in real-time. Some typical hypervisors are constructed to be a real-time hypervisor, but this solution still cannot meet hard time requirements because hypervisors have no knowledge of tasks inside a VM. Based on this two-tiered scheduling domain, this talk will discuss the challenges stemming from it, the benefits of real-time virtualization and some potential different approaches for constructing these solutions.

With well over 10,000 unique configuration options, it can be difficult to make your Linux kernel configuration a deliberate one. Each new version introduces new options, renames some and removes others. A static config is convenient at first, but it doesn’t distinguish between deliberate choices and the defaults, making it difficult to evaluate changes and prepare for upgrades. Configuration fragments have been part of build systems like the Yocto Project for years and later became more common with the addition of the script to the upstream Linux kernel. This talk will explore the complex task of Linux kernel configuration management through some common scenarios and pitfalls and show how granular configuration with fragments provides for a more deliberate and more manageable approach to Linux kernel configuration management.

Some applications benefit from moving closer to data ingest or the user. Edge reduces local processing latency and supports isolated operation. However, you won’t achieve the Google Borg experience at an edge location, nor are you likely to need it. But with planning it is possible to achieve edge deployments with predictable performance that are secure and “highly available enough” considering constraints on money, physical space, power, etc. This talk will provide specific recommendations related to architecture, networking, storage, patching, logging, disaster recovery and remote manageability when using Kubernetes and other open source tools.

Static tracing events have been in the kernel since Linux v2.6.31. They are extremely useful, common and well-known. Still, there’s always something else in the kernel that one would like to know about. This is where dynamic events can become handy. Not as well-known are kprobe events. These are events that can be created dynamically and have been available since v2.6.33. But they can be difficult to use and change from kernel build to kernel build. Coming soon are function-based events, which are tied to the function tracer. This talk will discuss the crazy things you can do with both function-based and kprobe events.

The Real Time patch has been developed out of the kernel since 2004. 14 years later, there is a real effort to finally make it into the mainline kernel within the next year. All the major roadblocks that kept it from being merged have now been solved. But once it is in mainline, all kernel developers will now be responsible for not breaking it. Being Real Time friendly is not hard; it actually forces you to write cleaner and more maintainable code. This talk will focus on what kernel developers will need to understand about PREEMPT_RT and whether they are writing core kernel code or some fringe kernel driver.

Ftrace is the official tracer of the Linux kernel, which allows you to shed light into every hidden corner of the kernel. The Ftrace data can be a valuable source of information when trying to study the performance of a system. On the other hand, reading the raw tracing data in a text format is difficult. Having a UI which provides interactive visualization and browsing inside this data can be extremely useful. This talk will present the new, completely redesigned KernelShark which does just that. Based on Qt, it’s optimized for efficient processing of significantly larger amounts of trace data. We’ll also present our ongoing development of KernelShark, focused on instrumentation for visualization of trace events across multiple VMs on the same host and the hypervisor itself.

Being an embedded developer requires a solid grounding in C. However, this results in a lot of time-consuming effort setting up build environments, compiling, figuring out how to upload things and a whole myriad of problems that tend to take far more time than you’d expect to get from opening the packaging on your new MCU to getting an LED blinking. There are some alternatives for some of the larger MCUs available—things like eLua, MicroPython and CircuitPython can now be loaded and allow you to control an MCU directly without the need to re-compile. This talk will take users through replacing the firmware on an MCU with the intention of contrasting the experience to how more traditional embedding is done.

Kubernetes is one of the high-velocity projects in the open source world today. With the latest release of version 1.12, it’s a great opportunity to see how core functionality and the ecosystem at large have matured. This also gives us a concrete look at where things are headed this year. This talk will dive into the significant number of enhancements to the open source project along with the most notable achievements from the entire ecosystem.


Be sure to stay tuned to the Open Source Blog and our Twitter handle (@vmwopensource) for more information leading up to Open Source Summit Europe and live updates from the conference itself. We hope to see you there!