FOSDEM welcome and opening talk.

Welcome to FOSDEM 2018!

The Open Source label was born in February 1998 as a new way to popularise free software for business adoption. OSI will celebrate its 20th Anniversary on February 3, 2018, during the opening day of FOSDEM 2018. The presentation will summarize the evolution of open source licences and the Open Source Definition (OSD) across two decades, explain why the concept of free open source software has grown in both relevance and popularity and explore trends for the third decade of open source.

Open source software is now ubiquitous, recognized across industries as a fundamental component to infrastructure, as well as a critical factor for driving innovation. Over the past twenty years, the OSI has worked to promote and protect open source software, development, and communities, championing software freedom in society through education, collaboration, and infrastructure, stewarding the Open Source Definition (OSD), and preventing abuse of the ideals and ethos inherent to the open source movement. The “open source” label was created at a strategy session held at the start of February 1998 in Mountain View, California. That same month, now almost twenty years ago, the OSI was founded as a general educational and advocacy organization to raise awareness and adoption for the application of free software in an open development process. Some of the largest forces in business today — consumer-facing companies like Google and Facebook, business-facing companies like Salesforce and SUSE, companies outside the tech industry such as BMW, Capital One, and Zalando, even first-gen tech corporations like Microsoft and IBM — all increasingly depend on open source software. Governments too, including the European Union, France, India, the United Kingdom, the United States, and many others have discovered the benefits of open source software and development models. Successful collaborative development of software and infrastructure used by these organizations is enabled by the safe space created when they use their IP in new ways... to ensure an environment for co-creation where the four essential freedoms of software are guaranteed. As open source adoption has expanded, we have seen changes in the assumptions surrounding licensing, governance and development of open source projects. We will document that evolution and look ahead to see what trends and pressures face the global free and open source software movement as it expands beyond ICT to wireless, distributed devices and beyond.

Welcome to the 2018 edition of the Free Java DevRoom!

Please note that this talk has been cancelled as the speaker is no longer able to attend FOSDEM.

See http://staff.bath.ac.uk/masjhd/MattColes.html for more background on the project.

Systems with large amounts of multi-level cache available require the ability to profile cache performance at each layer, as there remains a significant performance disparity between L2 and L3 caches. An example of such a system and the focus of this work is the new Cavium ThunderX2 supercomputer at the GW4 Isambard project. This paper intends to detail the methodology used to extend the capabilities of the Valgrind tool: Cachegrind. This extension will enable it to model both the L2 and L3 caches separately, as opposed to as a single last level cache. This support will be added for both the ARMv8 architecture, in order to model performance on the Isambard supercomputer, and in addition x86_64, for comparative purposes. As a result of this extension, the Isambard project will be able to optimise frequently used programs, in order to reduce CPU time used and therefore improve throughput on the system.

1) Current state of Valgrind, Cachegrind (possibly state of ARM?) 2) Adding the extra cache layer 3) State of Thunder X2 valgrind/cachegrind

The FreeBSD Foundation was founded in 2000, initially to own the FreeBSD trademarks and intellectual property. Over the past 17 years, we’ve grown from being run by 3 volunteer board members, to a team of 9 staff members, and 8 volunteer board members. My presentation will cover a little bit of our history, what’s our purpose, the key areas we focus on and why, and how we are making this a better world, by supporting FreeBSD, the community, and the overall open source ecosystem.

The purpose of my talk is to tell the BSD community about the work we are doing, and what we can do to help them. I will address the key areas we focus on and highlight the work we did in 2017, and why it was important to keeping FreeBSD relevant and innovative. I will have a Q&A session at the end, so attendees can ask questions about the Foundation, and what they'd like to see us working on in 2018. This will be a good opportunity to have a face-to-face dialogue with community members we don't normally get to talk to in person.

Go 1.10 is planned to be released in February 2018 and this talk covers what's coming up with it.

The residential heating division of Bosch thermotechnology is developing products for domestic hot water and central heating in homes. These products include an app (iOS and Android) connected smart room thermostat and a control unit for controlling a boiler appliances. During this presentation, we want to share our lessons learned by explaining our testing strategy and the usage of robotframework.

Specifically we will share our story about:

• Our usage of robotframework to test the mobile apps we develop. Show framework architecture for combined on target and simulator testing. How to test on several different real phones.
• The testing of the internet connected room thermostat with robotframework. How to handle (stub, mock or fake) the different (radio) interfaces.
• How we setup robotframework to test the embedded software with accelerated time. Show the architecture of the embedded software and how we can run this on both target and PC platform. How the modelled system dynamics were used during testing.
• Do's and dont's when testing a product during development.

About the authors:

• Alex van de Schootbrugge is an embedded software engineer working on the smart room thermostat.
• Windel Bouwman is an embedded software engineer working on the control units for boiler appliances.

Cypher is a property graph query language that provides expressive and efficient querying of graph data. Originally designed and implemented within the Neo4j graph database, it is now being used by several industrial database products, as well as open-source and research projects.

Since 2015 Cypher has been an open, evolving language, with the aim of becoming a fully-specified standard with many independent implementations. We provide a brief introduction to Cypher, the property graph model and the openCypher project, and then describe extensions – either actively being developed or under discussion – which will be incorporated into Cypher in the near future. These include (i) making Cypher into a fully compositional graph query language, by supporting multiple graphs and allowing graphs to be returned from queries; (ii) allowing for more complex patterns (based on regular path queries) to be expressed; and (iii) allowing for different pattern matching semantics – homomorphism, relationship isomorphism (the current default) or node isomorphism – to be configured at a query-by-query level.

In order to run containers and virtualization, admins need to take care of two infrastructure stacks. KubeVirt is one way to converge both stacks.

Virtualization is here, and Containers are on the rise. And Admins are having fun because they need to take care of two infrastructure stacks. Sometimes they are built on each other, but that effectively leaves you still with two control planes and APIs, one for containers and one for virtualization.

How would it be if you could manage your containers and VMs through the same API, and both of them would share the same infrastructure? Single API to perform automation, no need to duplicate monitoring, logging and authentication management. It’s the same if you add KubeVirt to a Kubernetes cluster, in order to teach it to run virtual machines.

This talk is about the idea by and implementation of KubeVirt the virtualization API and runtime for Kubernetes.

Feel free to arrive early, to start the day with some informal discussions while the set-up of the DevRoom is finished.

Embracing containers and micro-services with their scaling model and resiliency is the new frontier in software packet processing. This talk will describe the reasons, the challenges and opportunities of this trend.

DPDK revolutionized software packet processing initially for discrete appliances and then for Virtual Network Functions. Containers and micro-services technologies are extensively used as a means to scale up and out in the Cloud.

Containers and micro-services now include Comms Service Providers among their advocates, and embracing these technologies with their scaling model and resiliency is the new frontier in software packet processing. However there are challenges in decomposing Software Network Functions into Data-plane Micro-Services.

This talk will describe:- 1. The challenges of enabling robustness and scaling, while still meeting data-plane performance goals. 2. The use cases, the trends and the timelines. 3. The enabling work to date in DPDK and FD.io VPP, and the next steps.

Please note that this talk has been cancelled as Gervase Markham is no longer able to attend due to sickness. Our apologies for this inconvenience.

Mozilla Open Source Support (MOSS) is Mozilla's program for supporting open source projects financially and with security audits. Find out about our successes so far, and how you can apply for help for your project.

There are 3 main tracks in MOSS - "Foundational Technology" for projects Mozilla already uses, "Mission Partners" for projects doing work in line with Mozilla's mission, and "Secure Open Source", where we provide professional code-read security audits for key pieces of open source software.

So if your software is used by Mozilla in any way (part of Firefox, deployed in our infra, used on desktops, or any other way you can think of), or if your project does something you think furthers Mozilla's mission (check the manifesto, and our current work and where we are focussed), and money would help you do what you do better or faster, you should find out about MOSS and consider applying. We don't accept applications directly for the Secure Open Source track, but you are welcome to come and make your case to the presenter as to why giving your project a free code-read security audit from a professional audit firm would make the world a better place.

So, come to the presentation to find out about our successes so far, our plans for the future, and how you can apply for help for your project.

A review of the past year in the life of the OpenJDK Community, and a look at what's ahead.

A review of the past year in the life of the OpenJDK Community, and a look at what's ahead.

On Saturday 3rd February 2018 there will be numerous workshops hosted around the globe encouraging and advising newbie speakers to put together your very first talk proposal and share your own individual perspective on any subject of interest to people in tech. Mozilla and the Mozilla TechSpeakers will bring this global event to Brussels during the first day of FOSDEM, and during the workshop will also provide CFP help and mentoring to any of the FOSDEM participants.

Global Diversity CFP Day is an event happening across the globe, simultaneously in 40+ cities on the 3rd of February. The Brussels event is organized at FOSDEM as the libre conference/community gathering and the GDCFPDay dates coincide happening on the same weekend. The Brussels event is organized by the Mozilla TechSpeakers, a community program by Mozilla for empowering and improving the skills of community public speakers in Mozilla's open-source community.

Registration

Attending the CFP workshop is completely free but subject to registration. Please get your workshop ticket from the workshop ticket registration, and please don't forget to fill out the ticket-questionnaire, so we can make sure we can provide you with the best workshop experience with minimal distractions so you can concentrate on your improvement!

If the initial tickets run out, don't worry, we are reserving some workshop places for first-time speakers and members of under represented groups, so be sure to apply for the waitlist ticket and keep an eye on your mailbox, we will get back to you when we have some extra spots open up.

Mozilla TechSpeakers CFP-help

Cannot make it to the workshop? Just have some questions about public speaking or writing conference proposals? Drop by on Sunday between 09:30 and 11:30 in J.1.106 or at the Mozilla Booth between 14:00 and 16:00 and talk to some seasoned veteran Mozilla TechSpeakers about public speaking, or ask them questions about public speaking/cfp-s in general or your talk (idea).

Code of Conduct

All Mozilla events are governed by the Mozilla Community Participation Guidelines and this GDCFPDay workshop is no exception. The Community Participation Guidelines (CPG for short) of Mozilla contains the general conduct required of all Mozilla community events and serves as a Code of Conduct for all events organized by Mozillians, and events where Mozilla (and thus, Mozilla TechSpeakers) are represented. By attending the GDCFPDay even you accept to read, understand and act in compliance with regard to the expectations set forth in the CPG (the short version of which is "Be excellent to each other and treat each other with respect and care.", but please do read the "long version").

These expectations will be observed and proper conduct will be enforced, without exception, by the organizing team.

Any infringements or issues can (and should) be reported at the coc@tchspk.rs e-mail address or to the following people (in person or via the contacts listed below: * Istvan Szmozsanszky ("Flaki") - flaki@mozilla.hu / +1-929-433-7980 / @slsoftworks on twitter & telegram * Havi Hoffman - hhoffman@mozilla.com

This talk will discuss how Red Hat IT is moving from a centralized LDAP and kerberos setup to a Red Hat IdM setup for all of our Linux users and hosts.

As you'd expect, Red Hat IT has a very large Linux user base. For over a decade our associates have relied on Red Hat Directory Server (standard LDAP), MIT kerberos and some homegrown automation for most of their identity information and authentication. As we've grown overtime we have desired a more integrated and featureful solution. Red Hat IdM/FreeIPA is this solution.

This talk will go over what our old infrastructure was and what we are moving to. More importantly, it will cover all the snags we've hit along the way and what we did about them.

The <video> element was first proposed by Opera Software in February 2007. Opera also released a preview build that was showcased the same day and a manifesto that called for video to become a first-class citizen of the web.

Integrating video elements into the HTML5 standard has changed the world forever and for the better and enabled us to gradually rid ourselves from the proprietary, exploitable and often slow FLASH technology. However, the means to embed video in HTML5 enabled web pages is only the tip of the iceberg. In this session, we will discuss other crucial aspects of handling and serving video.

This session will cover in detail the following aspects and how we handle them in the Kaltura Open Source Video Platform:

• Video ingestion [uploading, encoding/transcoding]
• Content distribution and Caching
• Redundancy
• Metadata cataloging and Searching
• On-the-fly repackaging of MP4 files into DASH, HDS and HLS

We will conclude with an end-to-end demo of the Kaltura Video Platform.

MH is a personal effort to build systems based on a single, almost arbitrary, abstraction: the device. The original idea was that having a system with a limited, but easily understandable interface would allow to build systems that are easy to grasp and fun to extend.

This talk will tell about the experience of designing MH, the lessons learned, errors made, and what using and playing with such system looks like.

FrameRetrace is the first fully open-source graphics performance analysis tool for OpenGL on Linux platforms. It enables rapid experimentation with shaders, state, uniforms and experiments, to find and fix performance or rendering problems in a frame. This talk will describe the current state of FrameRetrace, and why it is a compelling tool for OpenGL application and driver developers. A demo of FrameRetrace will illustrate and fix a performance problem in the mesa driver.

In Linux 4.13, GPU performance counters were added to the kernel, dramatically expanding the information available to understand GPU performance bottlenecks on Intel platforms. FrameRetrace exposes these counters in a responsive UI, providing a detailed cost analysis for every aspect of a frame's rendering. The following live experiments allow a developer to alter the frame and immediately see the impact on both performance and rendering:

• shader editing and recompilation
• changes to GL state settings
• changes to uniforms values
• experiments (simple shader, disable render)

Because FrameRetrace is built on top of ApiTrace, it can analyze most OpenGL applications. It can also provide parallel analysis of the same frame on Windows and Linux platforms, to highlight driver differences. This key feature makes FrameRetrace especially powerful when enabling new hardware that has a well-supported driver for Windows. Hardware teams from AMD and Broadcom have expressed interest in FrameRetrace for enabling their platforms.

The current feature set of FrameRetrace is compelling, and Mesa driver team has already fixed many driver issues based on findings from the tool. I would like to encourage wider use of FrameRetrace, and solicit help in adding features -- especially support for AMD hardware.

Source and documentation available at: https://github.com/janesma/apitrace/wiki/frameretrace-branch

EspoTek’s Labrador is a tiny yet powerful device that transforms a PC into a fully featured electronics lab, complete with an oscilloscope, signal generator, logic analyzer, multimeter and power supply. Qucs (Quite Universal Circuit Simulator) is an integrated circuit (IC) simulator which allow to setup a circuit with a schematic entry graphical user interface (GUI) and simulate the large and small-signal (DC, AC, S-parameter, Harmonic Balance and noise analysis) of the microelectronic circuit. Both hardware and software are 100% open-source (FOSS). Both tools will be used to illustrate complete flow of the measurements, characterization and SPICE modeling of the semiconductor devices for EDA IC design applications. EspoTek’s Labrador and Qucs cointegrations thru embedded Octave scripts will be discussed as well.

Pulp is a platform for managing repositories of software packages, but it can store any kind of binary data (e.g. cat photos). The core provides a REST API and manages files, but the real value for users is delivered by the plugins which allows core to manage a content type like a cat photo. The upcoming 3.0 release of Pulp includes a relational database, a new REST API, and a semantically versioned plugin API. This talk is going to briefly explain how Pulp is used, highlight the technologies under the hood, demonstrate the REST API, and show off the plugin API that will be included in Pulp 3.0.

In which Leslie and Laura welcome everyone to the Community DevRoom 2018

Declarative systems, like Kubernetes are nice. Instead of forming the state of the system command-by-command, one just posts a set of declarative requirements. The system will try to adapt. While it easy to understand how to use such a system from the user perspective, it requires a complete rethinking for us engineers on how to integrate with such a system. Based on the experiences with extending Kubernetes for KubeVirt with the Kubernetes-Go-SDK, this session gives a short and concise overview on what is required to implement declarative flows in general and particularly in Kubernetes. Real-world examples and pitfalls included.

Declarative systems, like Kubernetes [1] are nice. Instead of forming the state of the system command-by-command, one just posts a set of declarative requirements. The system will try to adapt. While it easy to understand how to use such a system from the user perspective, it requires a complete rethinking for us engineers on how to integrate with such a system. Based on the experiences with extending Kubernetes for KubeVirt [2] with the Kubernetes-Go-SDK [3], this session gives a short and concise overview on what is required to implement declarative flows in general and particularly in Kubernetes. Real-world examples and pitfalls included.

[1] https://kubernetes.io/ [2] https://github.com/kubevirt/kubevirt [3] https://github.com/kubernetes/client-go

The Digital Transformation Team was born to build the "operating system" of the Italy, a series of fundamental components on top of which they can build simpler and more efficient services for the citizens, the Public Administration and businesses, through innovative digital products. Among the critical infrastructures, there's the way software is developed. Italy is betting hard on open practices, by not only opening the source code of the country, but also turning citizens and hackers into first-class participants of the digital transformation, giving them the power to develop and maintain software which impacts their daily life.

To sustain this switch, the Team is building hackerspaces throughout the country, to increase awareness of open practices, and is turning all developers paid with public money into open source contributors. After this talk, you will know how to "hack your government", how to participate in this change (even if you are not Italian!) and how we are working to spread this idea throughout all of Europe.

The talk introduces you to the work of the ODF TC. This includes insights into day-to-day work and also takes into account the developers' relationship to the ODF standard.

In order to retain talent in teams one important thing that has to exist is the feeling of belonging, and that can manifest itself through creating an inclusive atmosphere at work. The world is evolving into a global village. Various tools and products enable collaboration with people across the world. While this is a great thing that we should consider a blessing, the associated exchange of diverse ideas comes with some challenges. Join me to find out some of the key skills that could transform your team into a more inclusive place.

Python 3.0 was released 10 years ago. It's time to look back: analyze the migration from Python 2 to Python 3, see the progress we made on the language, list bugs by cannot be fixed in Python 2 because of the backward compatibility, and discuss if it's time or not to bury Python 2.

Python became the defacto language in the scientific world and the favorite programming language as the first language to learn programming.

Draft of the talk:

• Growing populary of the Python programming language

  • Defacto language in the scientific world, replacing other closed source and more specialized but limited language
  • Favorite programming language used as the first language to learn programming

• Port Python 2 code to Python 3

  • Port Python 2 code to Python 3

    • No: "Add support for Python 3", don't loose Python 2 support

  • Port Python 3 code to Python 2

  • Python changes to make the transition smoother:

    • PEP 414: u"syntax" reintroduced in Python 3.3
    • PEP 461: bytes % args, Python 3.5
    • More "Py3k" warnings added to Python 2.7.x
    • Linters like flake8 detect some issues
    • six, futures, modernize, 2to6, etc.

• Analysis of the transition

  • Good: At Pycon US 2014, Guido van Rossum announced that the Python 2.7 support was extended from 2015 to 2020 to give more time to companies to port their applications to Python 3.
  • Bad: 2to3: "drop Python2 support at once", don't work when you have dependencies.
  • If done again, would it be different? Yes, obviously.
  • Python 4 will be different than Python 3: no more "break the world" release, but a "regular deprecation period" release, as any other release. Break things, one by one :-)

• Bugs that won't be fixed in Python 2 anymore

  • Some bugs cannot be fixed without breaking the backward compatibility
  • Unicode Support
  • Python 2 I/O stack bugs: rely on libc stdio.h
  • Security: hash DoS, enabled by default in Python 3.3, Python 3.4 now uses SipHash
  • subprocess is not thread-safe in Python 2. Python 2 subprocess has many race conditions: fixed in Python 3 with a C implementation which has less or no race condition. Handling signals while forking in complex.
  • threading.RLock is not "signal safe" in Python 2
  • Python 2 requires polling to wait for a lock or for I/O. Python 3 uses native threading API with timeout and has asyncio.
  • Python 3 uses a monotonic clock to not crash on system clock update (ex: DST change).
  • Python 3 has a better GIL.
  • Python 2 inherits file descriptors on fork+exec by default. Python 3 don't: PEP 446.
  • Functions can fail with OSError(EINTR) when interrupted by a signal, need to be very careful everywhere. SIGCHLD when a child process completes, SIGWINCH when using ncurses. Python 3.5 restarts the interrupted system call for you.

• Performance

  • Python 3.6 is now faster than Python 2.7
  • https://speed.python.org/

• Evolutions of the Python language

  • Python 3.5

    • PEP 492: async/await "keywords" for asyncio. (Really keywords in Python 3.7.)
    • PEP 461: bytes % args and bytearray % args
    • PEP 465, a new matrix multiplication operator: a @ b.
    • PEP 448: Generalized unpacking: head, *tail = list mylist = [1, 2, **other_list] mydict = {"key": "value", **other_dict}

  • Python 3.6

    • PEP 515: million = 1_000_000
    • PEP 498: f-string: name = "World"; print(f"Hello {name}!")
    • PEP 526, syntax for variable annotations.
    • PEP 525, asynchronous generators.
    • PEP 530: asynchronous comprehensions.

• Bury Python 2?

  • "Python 3 only"
  • https://pythonclock.org/
  • http://www.python3statement.org/
  • Fedora 23, Ubuntu 17.10: no python2 (/usr/bin/python) in the base system
  • 2017, April: IPython 6.0
  • 2017, December: Django 2

The new Next Generation Internet initiative could be the first real opportunity to put large scale public funding to work to really fix the internet. With an order of magnitude of hundreds of millions of euro in research, development and engineering effort it can actually be a major step toward reaching the post-Snowden internet we want. NLnet Foundation and Gartner Europe that wrote the strategic vision for the Next Generation Internet initiative will present the work they did in a unique collaboration which sought the expertise of key organisations and communities in the field - like RIPE (the European regional internet registry), GÉANT (research networks), the European assocation of country domain name organisations, ISP associations, the internet exchanges, the open source community (FSFE), the digital civil rights community (EDRi) and Internet Society. So not just the separate communities that operate different 'layers' (or rather slices) of the technology but also what we consider 'ethical guardians' of the internet.

2018 celebrates the fifth anniversary of the Edward Snowden revelations. Full details about covert mass scale surveillance at internet scale stripped the internet naked of every romantic assumption we held about it. The news sent a transformative shock throughout the global technology community. We were all convinced the internet would soon fix these horrible security shortcomings now that we knew - although naivity was destroyed and the internet would never be the same again.

The world has fast forwarded itself five years. We must conclude - with some sadness - that the internet was not fixed for us. We are still waiting for major structural change. To the regular end user, a safe and secure 'post-Snowden' internet is far away: in day to day usage they still by and large have to use the same unfixed and insecure internet we had before.

In fact, things in some areas have gotten worse as other actors besides foreign state agencies have gained immense powers over us. We are now asked by social networks to turn all our nude pictures over to them voluntarily so they may protect us.

One reason for this sad state of affairs, is that it has take time to follow up the Snowden revelations by adequate political measures. And to be frank, it took a while for public funding organisations in Europe to even understand their crucial role in this. The internet is not going to fix itself. Many of the more promising efforts in this realm have been 'bottom up' efforts from individuals or small teams, but these isolated efforts miss critical mass to actually scale up and change the mainstream internet.

The new Next Generation Internet initiative could be the first real opportunity to put large scale public funding to work to really fix the internet. With an order of magnitude of hundreds of millions of euro in research, development and engineering effort it can actually potentially change the balance of power. The Europen Commission (where the money for NGI originates) did not try to invent such a strategy by: it invited NLnet Foundation and Gartner Europe to write a strategic vision for the Next Generation Internet and identify what needs to be done to really move the internet forward. NLnet Foundation is an independent public benefit organisation which was set up by pioneers of the European internet in the eighties, and which has been funding key open source initiatives for over two decades. Gartner Europe is an equally independent consulting company that knows what is being decided in board rooms before anyone else.

In a unique collaboration they sought the expertise of key organisations and communities in the field - like RIPE (the European regional internet registry), GÉANT (research networks), the European assocation of country domain name organisations, ISP associations, the internet exchanges, the open source community (FSFE), the digital civil rights community (EDRi) and Internet Society. So not just the separate communities that operate different 'layers' (or rather slices) of the technology but also what we consider 'ethical guardians' of the internet.

The NGI initiative has learned from the enormous failures of the past five years. Gone will be the need to create artificial consortia. Gone will be a lot of the bureaucratic paperwork. There is a clear vision. There is a plan. And there is money to fund the right things. Open source is seen as the key mechanism to make it actually happen, and the first calls for funding from the NGI initiative are out. Now what is needed is the developers to seize the opportunity to scale up and more importantly to connect their initiatives.

Fixing the internet is a 'moonshot plus' effort: the internet is the largest technical structure man has ever made, and the task at hand is to vastly improve its very operating fabric with 3 billion + people using it on a daily basis. This may essential to our daily operations, but it is equally or even more important for upholding our human values and basic human rights in Europe. In addition to new open source technology this will also require a larger political agenda of Europe as an integral part of the approach too - in some cases regulating the most predatory behaviour from bad actors might be necessary to restore health back to the internet.

Managing C/C++ dependencies has always been a pain, especially for cross platform projects.

Conan is a portable package manager, mainly intended for C/C++, that makes library packaging possible (even pleasant!).

After a brief presentation of Conan, I'll show how we're using it to deal with our new C++ project's dependencies.

Last time I had to rebuild dependencies (for the new MSVC release) was horrible, it took me (only) a week!

There were no build scripts for most of them, and I was a real newbie in dependency management. After hitting a lot of walls (e.g. MT vs MD, building Autotools-based projects on Windows, etc...), I swore never to go through that process again.

I've decided to give Conan a try when a new project was announced.

Within a couple of weeks, I've managed to build binaries for x86/x64, Debug/Release (including proper PDB packaging), shared/static, Windows/macOS/Linux. Integrating Conan to our CI system was trivial, upgrading a dependency is now a matter of minutes.

First, I'll show how to create, upload, and install packages before diving into cross-compilation with Conan.

PostgreSQL is a great community. They are open-minded, friendly, agreeable and so on. You feel like helping them.

The problem is you are shy and you look at community people as gods. On top of that you don't want to mess up with their work or bother them with obvious and silly (to them) questions!

This conference talk is based on my own true story. I will tell you about how I submitted my very first patch to the community. After some background presentation about how the community works, I will try to answer the following questions:

• What can I do to help (and you'll see that even without coding you can do a lot!) ?
• What's a contribution ?
• What's a patch ? How can I create one?

And I hope that sooner or later you'll come and join the community and you'll feel so proud of yourselves!

The STM8 is STMicroelectronics' current 8-bit microcontroller architecture. In recent years a free toolchain or the STM8 architecture appeared and quickly surpassed the non-free ones. The central part of the toolchain is the Small Device C Compiler (SDCC), which features some optimizations suited to highly irregular architectures such as the STM8 The talk introduces all parts of the free toolchain for the STM8 and also discusses remaining gaps.

The STM8 is a popular 8-bit architecture by ST Microelectronics commonly used in household electronics, automotive application and industrial controls. For quite a while there were no free tools, and the irregular architecture makes it hard to support in GCC or LLVM. In recent years free tools for it started to appear and now form a free toolchain that surpassed preexisting non-free ones. The most important part is the Small Device C Compiler (SDCC). New tree-decomposition-based algorithms from recent compiler research have been implemented in SDCC, including a new register allocator particularly suited to irregular architectures with few registers. SDCC quickly surpassed the non-free compiler in standard compliance and OS support and generates substantially faster integer code. Programs can be flashed by stcgal (via a serial link on STM8 devices that have a bootloader) and stm8flash (via the SWIM interface of ST-LINK hardware). OpenOCD and GDB allow on-target debugging via the ST-LINK. IDEs complete the development environment. However, stcgal still needs non-free binary blobs for use with some devices and the ST-LINK has non-free firmware. SDCC still falls short in floating-point performance. While there are some ports of free RTOSes that use the free toolchain for the STM8, more would be desirable.

Learn how to utilize the Delve debugger to dig into and solve complex bugs in your code.

Delve is a powerful yet simple open source debugger for the Go programming language. In this talk, I will discuss what makes both Go and Delve different from other languages / debuggers, and then dive into real world usage. I will begin by introducing the tool, and showing the basics of how it works. From there I will use specific example problems to show how to use some of the most powerful features of Delve to solve even the most complex bugs.

This talk will be beneficial to beginners and advanced users alike.

Learn how to utilize the Delve debugger to dig into and solve complex bugs in your code.

Delve is a powerful yet simple open source debugger for the Go programming language. In this talk, I will discuss what makes both Go and Delve different from other languages / debuggers, and then dive into real world usage. I will begin by introducing the tool, and showing the basics of how it works. From there I will use specific example problems to show how to use some of the most powerful features of Delve to solve even the most complex bugs.

This talk will be beneficial to beginners and advanced users alike.

I will start with a deep dive into the Go programming language. Topics of discussion will include the runtime, DWARF, scheduler, and more. From there, I will introduce Delve and discuss how it is different from other debuggers and walk through basic usage. After that I will switch over to a terminal where I will work through several pre-made bugs, highlighting certain features of Delve. The goal of this talk is to equip users with all of the knowledge and confidence they need to use Delve to effectively debug their programs.

This talk will present an overview of analog(ue) and mixed-signal simulation, with a focus on Gnucap .. the GNU Circuit Analysis Package.

I will introduce the basis of simulation, the basic "SPICE" methods (DC, AC, and transient analysis), mixed-signal (event driven) simulations, and "Fast-Spice". Also, some derived methods, including Fourier analysis, Harmonic Balance, and Periodic Steady State will be introduced. Along with this, I will review where the Free simulators (Gnucap, Qucs, NGspice, Xyce) stand.

I will also present the plugin based architecture of Gnucap, and how it encourages contributions and fast deployment without sacrificing quality of the base work.

Register allocator is a key component in Valgrind's VEX subsystem. Superficially it only translates virtual registers to the real ones. But is that really all? What actually happens under the covers, what algorithms are at play here and what are the constraints under which it operates?

Last year, a major overhaul of the Valgrind VEX register allocator has been done, resulting in a new version v3 which is now used by Valgrind. In addition to a new design, new register allocation algorithms have been also implemented, producing faster and smaller code.

A brief introduction to Valgrind VEX subsystem will be given, to put the register allocator component and its interfaces into context.

Then the operation of register allocator v3 will be presented in an illustrative way, including major data structures. Code snippets from amd64 and aarch64 architectures will be used for examples. Brief comparison with v2 will be also given.

After that, several algorithms will be described which contribute to the success of v3; again showing their operation on graphics.

Finally there will be some time for discussion and feedback gathering.

In this talk, we highlight how important automated testing is to sustain the upstream development model of Linux, especially when products are involved. We will then give you a tour of our system, how it integrates with the developer's workflow, what we are working on, and we managed to grow from a couple of thousands tests executed per week to over 4 millions!

We will also present the changes we have done to the IGT test suite to become less Intel-specific and serve the needs of multiple drivers.

Upstream development requires never regressing the features that were already present in previous versions. We believe that this is not only the right thing to do, it is also increasing in relevance as more and more products move towards this model. To embrace this model, we try to catch unintentional regressions as early as possible through our CI system. This improves the productivity of our developers (fewer bugs coming months after the code was committed), and provide users with a smoother upgrade path (either through the product manufacturer or by upgrading the kernel themselves).

The Intel GFX CI has grown massively in the past 1.5 years: the number of machine doubled; the test coverage went from 260 tests/machine up to over 4k; the number of tests executed went from 100k/week to over 4M; pre-merge testing time dropping to an average of 30 minutes despite the increased usage.

We will then tour the audience through our different services, how they integrate with the developers' workflow, and how we manage to keep track of failures (and file them).

Finally, we will share what are our current developments, our goals, and what we are doing to the IGT test suite in order make it useful for more drivers than Intel.

Welcome to the Ada Developer Room at FOSDEM 2018, which is organized by Ada-Belgium in cooperation with Ada-Europe.

Ada-Belgium and Ada-Europe are non-profit organizations set up to promote the use of the Ada programming language and related technology, and to disseminate knowledge and experience into academia, research and industry in Belgium and Europe, resp. Ada-Europe has member-organizations, such as Ada-Belgium, in various countries, and direct members in many other countries.

More information on this DevRoom is available on the Ada-Belgium web-site.

Software Defined Networking (SDN) may have started as the separation of the control plane and the data plane, but the true power lies in the ability to communicate with the network through well defined interfaces using standard protocols. This session provides a brief intro to SDN in general, and more specifically to OpenDaylight, an open source platform for programmable SDN. Next we dive into network programmability, including why we need it and the role of NETCONF, YANG, and RESTCONF. Then we put the theory into practice as we install OpenDaylight as use it a platform for programming a sample network.

Migrating from CVS to a modern VCS is challenging for old and large projects. When limitations of older hardware join, the true fun begins.

This talk explores some of the issues found while evaluating Mercurial as new VCS for NetBSD and how they got resolved.

The NetBSD project has been developing an Operating System for almost 25 years now. It is one of the oldest users of CVS still around and there is a strong desire to change that. Such a migration is challenging and requires acceptance from the active developers and infrastructure changes. One central aspect for the buy-in from the community is the scalability of the new system and its limitations.

The talk starts with an overview of the existing work on migrating the NetBSD repository to modern VCS. The performance of important operations will be compared and bottlenecks identified. Based on the results, reasonable target requirements are identified. An in-depth analysis of critical parts of Mercurial will be presented and how those bottlenecks were addressed.

An overview of the main features of the Ada language, with special emphasis on those features that make it especially attractive for free software development.

Ada is a feature-rich language, but what really makes Ada stand-out is that the features are nicely integrated towards serving the goals of software engineering. If you prefer to spend your time on designing elegant solutions rather than on low-level debugging, if you think that software should not fail, if you like to build programs from readily available components that you can trust, you should really consider Ada!

Through the introduction of new hardware features in recent GPUs it becomes feasible to implement proper isolation between different graphics applications. In this talk we will present a user space GPU multiplexer solution for Intel Gen8+ that takes advantage of those hardware features. It supports the concurrent execution of multiple 3D applications, while still retaining a low code complexity. Furthermore, we will give an holistic overview of the inner workings of a modern graphics stack.

Have you heard about USE Method (Utilization - Saturation - Errors), RED (Rate - Errors - Duration) or Golden Signals (Latency - Traffic - Errors - Saturations) ?

In this presentation we will talk briefly about these different, but similar “focuses” and discuss how we can apply them to the data infrastructure performance analysis troubleshooting and monitoring.

We will use MySQL as example but most of the talk will apply to other database technologies as well.

Have you heard about USE Method (Utilization - Saturation - Errors), RED (Rate - Errors - Duration) or Golden Signals (Latency - Traffic - Errors - Saturations)? In this presentation we will talk briefly about these different, but similar “focuses” and discuss how we can apply them to the data infrastructure performance analysis troubleshooting and monitoring. We will use MySQL as example but most of the talk will apply to other database technologies as well.

This talk will introduce Æ-DIR, a paranoid identity and access management (IAM) system based on pure OpenLDAP. The talk will detail the data model used for delegated administration and its use e.g. for a strictly authorizing SSH proxy.

Furthermore it introduces OATH-LDAP, a OATH-based OTP authentication system with pure LDAP backend and the enrollment process used for secure initializing yubikey tokens.

The conclusion of the talk will highlight want else will be done with the data and role model in the near future.

Æ-DIR and OATH-LDAP are free software projects.

This talk will present a concept and real-world implementation of a privileged identity and access management system (IAM, PAM) purely based on OpenLDAP. The main goal of Æ-DIR (besides challenging Unicode handling in various software with its name) is to follow the delegation, need-to-know and least-privilege principles as strict as possible. The visibility of user, group, sudoers, etc. is limited by OpenLDAP’s set-based ACLs. All systems and services, no exception(!), have to individually authenticate to be authorized to access Æ-DIR.

The talk will give some additional information about the secured base configuration of OpenLDAP, tools developed and some experiences made when migrating/attaching 7000+ servers to this user management.

Furthermore the architecture of a SSH gateway is shown which uses the very same access control data to authorize SSH connections passing through the gateway.

Finally the talk will outline some additional to-dos, and rough ideas how to further develop this system.

OATH-LDAP defines a schema, a functional model and a LDAP-based enrollment for OATH-based authentication tokens. It is designed to be used with any LDAP server, but especially is ready-to-use integrated with Æ-DIR. It is actually used combined with a highly secure enrollment process (no QR code displayed!) for two-factor HOTP authentication with yubikey tokens.

Abstract

Graph pattern matching is one of the most interesting and challenging operations in graph analytics. Query languages like openCypher, implemented in systems like Neo4j, SAP HANA Graph and Redis Graph, allow the intuitive definition of graph patterns including structural and semantic predicates.

For now, graph query languages are most prominent in graph database systems such as Neo4j. However, we think that many systems can benefit from having such a language in their toolbox. One of these systems is Apache Spark, which is one of the most popular open source frameworks in the context of distributed processing of large data volumes within complex analytical workloads. To bring the benefits of Cypher from the graph database realm into the world of Big Data, we at Neo4j started developing Cypher for Apache Spark (CAPS). CAPS is primarily focused on graph-powered data integration and graph analytical query workloads within the Spark ecosystem. In addition, CAPS is our testbed for Cypher language extensions as specified in the openCypher project; for example, multiple graphs, graph transformations and construction, and query composition.

In our talk, we want to motivate use-cases for CAPS and give an overview of new querying capabilities which we demonstrate using Apache Spark and Apache Zeppelin. Furthermore, we briefly present the internal architecture highlighting the main differences between Neo4j and CAPS.

Intended audience and goal of the talk

Developers and analysts, trying to express graph queries on distributed graphs

Links to background information on the given talk for the hungry and impatient

• OpenCypher
• Neo4j
• Apache Spark

Links to previous talks, code snippets or repositories

• CAPS

This may come as a surprise but it is already possible to run nested KVM inside Hyper-V VMs (and this includes several instance types on Azure). Such workloads, however, may not always perform very well. Some limitations come from x86 architecture and conceptual differences between KVM and Hyper-V, other issues could be dealt with within KVM. In this talk Vitaly will go through different performance bottlenecks of nested KVM-on-Hyper-V deployments. The presentation will mainly be focused on low-level features: hardware support for nested virtualization, clocksources and clockevents, virtual device drivers. Benchmark data and general thoughts on the usefulness of such deployments won't be missing too.

In the talk Vitaly will try to highlight challenges in heterogeneous nested virtualization, namely the current status, issues and future work for running KVM on top of Hyper-V. The talk is intended for everyone interested in virtualization technologies. Less experienced people may learn about the very basics of virtualization in nested environments (and, actually, virtualization in general), experienced developers may find something interesting in learning about 'non-traditional' nesting, review the suggested approaches or even suggest a solution.

Much has happened in the last year for developers contributing to OpenJDK: - the repositories have been consolidated into a single repository - the run-test make target has been introduced - the JTReg (and jcov, asmtools and jtharness) build have been greatly improved - there is now a binary build of OpenJDK that can be used as --boot-jdk (on Linux x86-64)

The situation for HotSpot developers has also improved over the years: - the HotSpot build system was converted to the "new" build system - a proper unit test framework for C++ code (googletest) was added - debug symbols are no longer zipped by default - the JDK and HotSpot JTReg testlibraries were combined into one

This talk will show how all these changes make the OpenJDK developer experience a lot smoother. The speakers will also share their personal tips and tricks on how to work even faster on OpenJDK!

We also realize that the OpenJDK developer experience is far from optimal, and would therefore like this talk to initiate a discussion on what could be improved and how people can get involved.

In a world of constant news cycles, getting the word out about your project seems nearly impossible. You've got a web site, a Twitter and a Diaspora account, and still it seems like no one is showing up at your virtual doorstop. But there is one old-school toolset at your disposal that can help you and your project be recognized for the awesome you know it to be: the media.

In a world of constant news cycles, getting the word out about your project seems nearly impossible. You've got a web site, a Twitter and a Diaspora account, and still it seems like no one is showing up at your virtual doorstop. But there is one old-school toolset at your disposal that can help you and your project be recognized for the awesome you know it to be: the media.

There's a whole industry of people out there who are looking for stories to tell about the new and the innovative. You just have to know how to cultivate relationships and tell your stories in a way that will make your project interesting to more people. Brian Proffitt, a journalist and editor with over a quarter century of experience, will walk you through techniques to get your story out, including crafting a press release, targeting media outlets, and building trustworthy relationships with journalists (yes, it can be done).

Topics List:

• Targeting media outlets
• Writing your own press releases
• Becoming a knowledge expert
• Working with the press

Designing custom hardware, though might seem intimidating at first, can simplify many activities. It solves certain issues, but often raises many others. Paweł will present a fresh open hardware approach at providing remote access (including device flashing, debugging and power management) to embedded devices - MuxPi, successor of SD MUX board (showcased during FOSDEM 2016 and Embedded Linux Conference 2016).

Presentation will introduce novices to the topic of testing on remote embedded devices and previous attempts to do so. It will focus on software components of the new Tizen GNU/Linux distribution's testing laboratory (currently in the process of being published open source):

• Boruta - board farm management system,
• Weles - LAVA-compatible testing framework,
• Perun - binary image testing system.

Advanced capabilites of presented hardware (MuxPi) are discussed during talk in Embedded, mobile and automotive devroom.

This talk will hopefully encourage discussion on this topic or inspire attendees to try those components out in their own setups and share feedback on what can be further improved.

The TTML Profile for Internet Media Subtitles and Captions (IMSC) is the most promising candidate for a long awaited harmonized subtitle format for the Web. The open source library imscJS is not only a polyfill to render IMSC subtitles in the browser: as an open reference implementation it is a blueprint how to integrate IMSC subtitles in other open source projects e.g. in video players. The presentation will show how imscJS parses and renders IMSC subtitle files, where imscJS is already used and how the open source ecosystem for subtitles could benefit from it in the future.

In this talk we'll discuss networking in Go. We start off with a review of the stdlib net package and its sub-packages and then walk through common use cases, patterns and challenges. In the second part we focus on best practices using the stdlib and community-provided frameworks such as gorilla/websocket and gRPC.

In this talk we'll discuss networking in Go. The goal is to provide beginners with a comprehensive overview of what the stdlib offers as well as what packages outside of the stdlib exist that can be used for networking. More advanced users can benefit from networking best practices and guidance for implementing distributed systems.

The talk is has two parts:

Part 1: Basics

We start off with a review of the stdlib net package and its sub-packages, walk through common use cases, patterns and challenges:

• Discussion of net and sub-packages (main types, interfaces, understanding what is available)
• Socket-level programming
• Timeouts, retries
• Security
• DNS

Part 2: Best practices and beyond stdlib

In the second part we focus on best practices using the stdlib and community-provided frameworks for networking:

• Best practices writing networked applications
• Review of non-stdlib packages useful for networking: golang.org/x/net/websocket, gorilla/websocket, gRPC

An year ago I done a talk about WebExtensions and how much they are a cool, a year later and after Firefox 57/Quantum what is waiting to devs and users of the most customizable browser? Let's see together what is happened and what is coming to us!

Starting from the actual APIs, what you can do right now, what is missing and how you can help to improve the extensions API.

The ongoing work to improve the accuracy of definedness tracking in the face of newer more aggressively optimizing compilers.

Valgrind's Memcheck tool reports various kinds of errors. One of the most important ones are those where an if-conditions or a memory address uses undefined data. To do this, it tracks the definedness of every bit in the process, and "follows" any undefinedness through arithmetic operations (Add, Sub, Mul, Or, Xor, etc).

This tracking is expensive and so Memcheck makes compromises, trading off exactness for speed. That has worked well for many years. However, as compilers become more aggressive, this works less and less well. In particular, Memcheck now often reports false errors in optimised code from GCC 6, Clang 4, and later versions. This is a problem because one of Memcheck's main strengths is the accuracy of its analyses.

In this talk I'll present my ongoing work to improve accuracy of definedness tracking. I'll mostly talk about various examples involving integer addition and comparisons, and will avoid gory details of Memcheck's internals. I'll also show two problems to which I have no solution.

The talk should be accessible to anyone with some familiarity of basic integer arithmetic (add, sub, and/or/xor, etc) and is curious about how undefinedness "flows" through these operations. If you like maths and proving simple theorems, you might enjoy this talk too -- and we'd like to talk to you!

The conference will describe how to use PREEMPT_RT and Xenomai with Yocto build system - building image and SDK - developing simple application - testing performances

Yocto is the most famous build system for embedded Linux. Today most of BSPs are provided as Yocto "recipes" and/or metadata.

They are several extensions providing RT capabilities to the Linux kernel. Number one is PREEMPTRT, maintained by Thomas Gleixner and supported by the Linux foundation since 2015. Second one is Xenomai mainly based on a co-kernel architecture (such as RTLinux). It was created by Philippe Gerum, a french RT expert and is maintained by a small group of contributors. Current version is 3.0.5 and can be used in dual kernel mode (Cobalt) or on top of PREEMPTRT in a single kernel approach (Mercury).

Using RT extension with Yocto is not that easy because linux-yocto-rt kernel is not usable on main embedded target such as ARM (as it works on QEMU target only). Using Xenomai is much more complicated as it needs several steps (patching the kernel, installing user-space libraries, building an extended SDK).

During the conference we will decribe how to build a Yocto Linux image using PREEMPT_RT for famous boards such as Pi 3 or BeagleBone Black.

Some Xenomai support is provided by meta-eldk from DENX but it supports only Xenomai 2.6. We will describe meta-xenomai as we maintain it for our customers (available on GitHub). That new meta-xenomai layer is based on Xenomai 3.x and very recent kernel.

Then we will explain how to build a simple Xenomai application based on a periodic task. Finally we will compare performances of both extension (PREEMPT_RT and Xenomai) on same hardware.

A distro package environment such as Debian and a language-focused package environment such as npm may seem very similar at first. But underneath, they are very different in their goals, features and approach to create packages and manage dependencies.

Some package management environments are bazaars and some are cathedrals. What does this mean? Join me for a tour of horizon to compare and contrast the goals and ways of key package package management environments: What's their purpose? How we use then and how they are meant to be used? How do they deal with dependencies differently and why? Who creates and uses the packages?

A clear answer to these questions can help to better leverage these package environments, management tools and repositories or registries.

The talk will present Ligato - an open source platform for creating cloud-native VNFs. We will give the motivation and background for developing Ligato, describe its the architecture, and provide examples or real-world use cases. We will compare the performance and scale of Ligato-based VNF deployments with performance and scale of VNFs deployed in other environments, such as OpenStack.

A virtual network function (or VNF), as commonly known today, is a software implementation of a network function that runs on one or more virtual machines (VMs) on top of the hardware networking infrastructure — routers, switches, etc. Individual virtual network functions can be connected or combined together as building blocks to offer a full-scale networking communication service. A VNF may be implemented as standalone entity using existing networking and orchestration paradigms - for example being managed through CLI, SNMP or Netconf. Alternatively, an NFV may be a part of an SDN architecture, where the control plane resides in an SDN controller and the data plane is implemented in the VNF.

A cloud-native VNF is a VNF designed for the emerging cloud environment - it runs in a container rather than a VM, its lifecycle is orchestrated by a container orchestration system, such as Kubernetes, and it's using cloud-native orchestration paradigms. In other words, its control/management plane looks just like any other container based 12-factor app. to orchestrator or external clients it exposes REST or gRPC APIs, data stored in centralized KV data stores, communicate over message bus, cloud-friendly logging and config, cloud friendly build & deployment process, etc., Depending on the desired functionality, scale and performance, a cloud- native VNF may provide a high-performance data plane, such as the VPP.

Ligato (https://github.com/ligato) is a Golang platform for building cloud-native microservices. Although it was originally intended for development/implementation of custom management/control plane agents for cloud-native Virtual Network Functions (VNFs), it can be used to develop any microservice. Each management/control plane app built on top of the CN-Infra platform is basically a set of modules called "plugins", where each plugin provides a very specific/focused functionality. Some plugins are provided by the platform itself, some are written by the app's implementors. In other words, the Ligato platform itself is implemented as a set of plugins that together provide the platform's functionality, such as logging, health checks, messaging (e.g. Kafka), a common front-end API and back-end connectivity to various KV data stores (Etcd, Cassandra, Redis, ...), and REST and gRPC APIs.

The platform is modular and extensible. Plugins supporting new functionality (e.g. another KV store or another message bus) can be easily added to the existing set of Ligato platform plugins. Moreover, Ligato based apps can be built in layers: a set of app plugins together with platform plugins can form a new platform providing APIs/services to higher layer apps. This approach was used to create a management/control plane agent for VPP (https://FD.io). The VPP Agent is basically a set of VPP-specific plugins that use the core Ligato platform to interact with other services / microservices in the cloud (e.g. a KV data store, messaging, log warehouse, etc.). The VPP Agent exposes VPP functionality to client apps via a VPP-specific model-driven API. Clients that consume this API may be either external (connecting to the VPP Agent via REST, gRPC API, Etcd or message bus transport), or local Apps and/or Extension plugins running on the same CN-Infra platform in the same Linux process.

LibreOffice like other office suites, is a sophisticated, ubiquitous and complex end-user application, that demands good documentation to continue its strive. The current situation for LibreOffice documentation is that producing contents is still a lenghty and hard task, often requiring rework depending on different sort of publiccation needed. In this presentation, we will summarize the efforts done so far within the LibreOffice ecosystem and make the point on the need for a different approach to make the LibreOffice documentation an element of communty gathering and contribution, extending the range of the quality of the software.

Complex softwares for end-users like office suites or desktop environment, to name a few, are impacted in their adoption because of the need to educate and train users to the new tools. Undocumented software raise a set of issues that prevents broad adoption by the organizations or governments, and leave brilliant ideas and features into obscrurity. The Document Foundation and it's flagship software LibreOffice, as well as other FOSS communities needs to address the issue of making the end-user documetnation broadly available and updated.

On the other hand, end users being part of the software community, are often eager to collaborate and contribute to the software documentation, but hit a quite steep entry barrier because of the development skills need in editing software help files or on advanced word processing skills for editing a guide with the software. Also, Q&A-shaped web services, wikis and dynamic multimedia documentation also bring challenges to documentation because of the need for accuracy and update.

The purpose of the presentation is to deliver a vision on the optimal documentation production for complex end-user softwares, that will address several documentation issues existing in the FOSS business and community envoronment. We call this Project Convergence. Here is waht we foresee:

• Address the reduction of documentation rework, issues by the multiple publishing medias, such as online reading, printed guides or multimedia documents
• Have its contents editable by a large set of contributors, under proper security, and with the easiest way to add contents, so new contributors can quickly add contents instead of learning obscure features of the file markup.
• Be computer-aided-translation (CAT) friendly, to reach the broader public around the world in whatever language.
• Synchronized with the latest developments of the software, thus reducing the gap between development and documentation.

We will also present our latest development in the documentation tools of LibreOffice, in the effort to evolve technologically and benefit of the develpment of the web and invite for discussion all documentation leaders of similar software projects.

One of Hurd's goals is to isolate hardware drivers, to provide flexibility and safety, by isolating drivers' possibly erratic behavior, delegating driving hardware to unprivileged users, etc.

We are thus currently working on a PCI arbiter, which allows to let different userland drivers access PCI devices concurrently, while paving the way for fine-grain per-user, per-session, etc. permission management over PCI access, the use of IOMMUs allowing to do that very safely.

Strap in for a high-speed deep dive into JVM features now on the drawing board, which will benefit Java and all other languages that run on the JVM.

The talk will describe freeIPA client and server installations using anisble-freeipa with examples.

The client installation and configuration using ansible-freeipa provides some simplifications and extensions of the normal installation process like for example the possibility to install several clients, a simple use of one time passwords, enhanced server discovery and also the repair mode.

The server installation and configruation part is currently work in progress, but should be complete for the talk.

All large companies use free and open source software. Many of them contribute to free and open source software, and some of them publish their own free and open source software. All of this is good, and should be encouraged to continue.

In addition to that, though, many large companies have philanthropic arms; charitable foundations either operated by the company or closely aligned with the company, and primarily funded by the company. These foundations generally have focus areas, which include almost every conceivable charitable cause except... free and open source software!

This presentation will talk about Bloomberg's journey to add software philanthropy to its global charitable contributions, including the mundane aspects of running volunteer coding events, soliciting mentors/leaders to participate, organizing employee (and non-employee) participation, and others, but also how this type of philanthropy can be included in 'employee giving' and similar programs. Anyone who runs an Open Source Program Office, or similar group, within a company that also has a philanthropic arm should consider including free and open source software contributions in their plans, and this talk will help you get started.

Prometheus is often associated with modern architectures, cloud-native applications, and dynamic container platforms. While new applications can be designed to integrate well with cloud infrastructure and monitoring, most organisations also have to operate legacy applications that do not fit well into these environments.

This talk shows how to monitor legacy Java applications with Prometheus. The goal is to have Prometheus as a central monitoring tool that integrates both, modern cloud-native applications as well as legacy Java EE applications.

arbglspirv: bringing SPIR-V to Mesa OpenGL

Since OpenGL 2.0, released more than 10 years ago, OpenGL has been using OpenGL Shading Language (GLSL) as a shading language. When Khronos published the first release of Vulkan, almost 2 years ago, shaders used a binary format, called SPIR-V, originally developed for use with OpenCL.

That means that the two major public 3D graphics API were using different shading languages, making porting from one to the other more complicated. Since then there were efforts to allow making this easier.

On July 2016, the extension ARBglspirv was approved by Khronos, that allows a SPIR-V module to be specified as containing a programmable shader stage, rather than using GLSL, whatever the source language was used to create the SPIR-V module. This extension is now part of OpenGL 4.6 core, making it mandatory for any driver that wants to support this version.

This talk introduces the extension, what advantages provides, and explain how it was implemented for the Mesa driver.

NetBSD has had support for cross compilation for some time now. This talk covers the features and changes in NetBSD enabling a new comer to set out from obtaining a copy of the NetBSD source code and pkgsrc to building an OS & Firmware for an ARM board from scratch on an operating system of their choice.

NetBSD has had support for cross compilation for some time now. This talk covers the features and changes in NetBSD enabling a new comer to set out from obtaining a copy of the NetBSD source code and pkgsrc to building an OS & Firmware for an ARM board from scratch on an operating system of their choice. This was leveraged as the basis for a series of workshops aimed at introducing the NetBSD operating systems to hardware ethusiasts.

The workshops covered: Introducing project rescources (source repo & documentation) Cross compilation with ease The Lua subsystem - a highlevel language interface to the system Working locally using simulation Rapid prototyping with rump Tamper resistence with veriexec

The Ada programming language was designed for embedded programming and it is well known in the aerospace domains and in general every domain where failure is not an option. Unfortunately it is not used a lot in the embedded FOSS community.

In the past two years, AdaCore worked to promote the use of Ada in the FOSS community, in particular for embedded programming with the "Make with Ada" blog post series, my "Programming is Too Difficult for Humans" interview for the Embedded.fm podcase, "Ada Driver Library" blog posts on "ARM Community", or the "Make with Ada" embedded software project competition.

In this 45 minutes lecture I will:

give a short introduction of Ada for embedded and how its features (programing by contract, strong typing, representation clauses (hardware mapping), OOP, static compiler checks and optional run-time checks) can help improving the development time, maintenance and quality of FOSS embedded projects;

present the AdaDriversLibrary project, where we put all those features in practice to develop micro-controller device drivers in Ada;

make a quick getting started demo;

present some of the best projects from the "Make with Ada" competition.

Goal of this presentation is to explain what is FD.io/VPP and how it is integrated with OpenStack neutron.

VPP is a fast network data plane, part of the Linux Foundation FD.io project. It is designed on top of DPDK to run network workloads at ludicrous speeds using vector packet processing technology.

Networking-VPP is a VPP network driver for Neutron designed to take advantage of VPP’s performance. VPP brings the performance; Networking-VPP brings the resiliency, simplicity, security and scalability required to make it useful in OpenStack environments.

We’ll talk about what VPP is and why it’s a good choice for network workloads, particularly demanding ones such as NFV applications; how the ML2 driver is put together and why you can trust it to hold up in cloud environments (and even debug it); and the performance we see when we put the two together in a real world OpenStack deployment.

A lot happened in Firefox' devtools this year. Follow along with us for a tour of what changed this year, and how you can help !

This talk will be split in 2 parts:

1. This will be a general tour about the tools: what happened this year. This part will be more focused on the console, the inspector, the netmonitor, the debugger. (by Nicolas Chevobbe, developer in the Console)
2. How to read a performance profile recorded with the Gecko Profiler, using perf-html.io. (by Julien Wajsberg, developer for perf.html)

As containers and orchestration technologies went from niche to necessary tools to build modern distributed systems, traditional testing is no longer enough. e2e cases represent a great solution, but it's often easier said than done. In this talk, I will share my experience of building a testing framework for distributed systems, revisiting common mistakes, how to avoid them, and showing how to take advantage of the power of Go to make sure our systems behavior match our original expectations, with scalability in mind through automation.

Containers are everywhere. Whether teams decide to use bare containers, orchestrators or enterprise solutions built on top of these technologies, the result is the same in terms of testing.

With rolling updates and fault-tolerant clusters getting more popular every day in organizations of all sizes, availability issues are now easier to handle, whereas the complexity of reliability in our systems stays the same or even increases.

Given the nature of distributed systems, a traditional approach towards testing is not enough. Smoke, integration and unit tests should be only the entry point, while e2e tests are no longer a luxury item in our developer toolset. However, writing and running them with scale and time constraints in mind is a task that is easier said than done.

Since Go was born with tools for developers in mind, it's a great language thatenables productivity, which sometimes is cited as an excuse to avoid writing stronger e2e cases. In this talk, I will share my experience of building a testing framework for distributed systems, revisiting common mistakes, how to avoid them, and I will show how to take advantage of the power of Go to write reliable e2e tests to make sure our systems' behaviors really match our original expectations, with scalability in mind through automation.

It is impressive how much time and resources a team can save by using the OBS to manages their packages creation and distribution. OBS is a generic system to build and distribute packages from sources in an automatic, consistent and reproducible way.

Andrew Lee will cover the benefits of using OBS, explain some of it features and workflow for all your packaging and releasing needs, like automatically build package from scratch on multiple target distros and architectures, easy access through QA to the developer's repo to generate new images with the changes for testing before integration into the production repo, vcs-like workflow as branch code, send merge requests and review submissions and flexible to connect additional resources to empower the backend worker(builders) even with different architectures. At the end tips on how to setup and optimize OBS will be provided.

This is your chance to meet with key GNU Radio developers and help guide the future directions of GNU Radio development

This talk should explain the internal mechanisms and differences between three schedulers that are currently used to plan workload placements in today’s datacenters and clusters.

The scheduling part of cluster management is commonly perceived to be complicated and close to dark magic. My goal is to describe the really simple concepts all three schedulers are based upon. I will then focus on the significant differences and strong and weak points of each of them in hope that I will uncover features worth of sharing between schedulers.

This talks should shed some light on how cloud and cluster scheduling works and facilitate the idea exchange in the scheduling area; both in the developer community and between developers and users.

There are scads of options presented by GnuPG, which are all part of making it the flexible and powerful an encryption framework that it is. But it's extremely complicated to get started with, and that quite reasonably puts people off.

EasyGnuPG is a wrapper script that tries to simplify the process of using GnuPG. In order to simplify things, it is opinionated about the "right" way to use GnuPG.

The philosophic goals here are these:

1. Make GPG as easy to use as possible. The more people using strong encryption, the better for everyone. One of the big hang ups right now is that the GPG tools are difficult to use - more so than they strictly have to be.

2. Make the interface itself auditable. This is why this is presented as shell scripts rather than a web service or a GUI. If you're concerned about what egpg does, open up the files and read them, or have someone you trust read them.

3. Build a guide forward. The simplified interface provided here should be good to get started with, and with luck many users will find they never need anything beyond what egpg provides. If you find that you need to do something more, though, the goal is that you have a foundation to start with, and some direction on how to proceed.

4. Make it customizable. If it doesn't fit your workflow, adapt and extend it to fit your way of doing things. Share your extensions with the others too.

You have no hardware knowledge and want to know how people design chips ? You are a software guy, having heard of VHDL or Verilog but never used it ? In this 25 min tutorial, you will learn the basis of hardware design and how to write a simple FPGA design using only FOSS tools. (This tutorial is not about PCB design, but reprogrammable chips design)

This is the same talk as the one of FOSDEM'17. As the room was full, some people were not able to attend so I propose to do it again.

Userspace software is imperfect and we all know about this. Running it for 5 minutes seems to be easy but what about days or weeks? This problem already gave server guys a lot of sleepless nights. Nowadays also IoT and embedded Linux world is facing very the same problem. Unfortunately solutions known from server world (Nagios and friends) usually cannot be directly applied.

During this talk Krzysztof will discuss problems related to monitoring and "healing" embedded Linux distribution. First, most common server approaches will be described. After that, Krzysztof will try to identify key problems of applying this solution to embedded platform. Then Krzysztof will introduce faultd - small but extendable daemon for system monitoring and CPR;). How to use it? What can it do? What are the advantages and disadvantages? All those questions should be answered in this part. Last part is going to be a discussion on a presented idea and experience sharing.

Pythran is an open source compiler for scientific kernels written in Python.

Its goal is to turn scientific kernels written in Python into native modules that runs much faster, take advantage of SIMD instruction units, multi-cores, get rid of the GIL without sacrifying high-level programing. As such it understands a strict subset of the Python language, keeping 100% backward compatibiliy with the original language.

Looks cool? It is. But the target niche is small (high performance computing in Python and several great tools already exist (Cython, Numba). How have Pythran survived in the OSS jungle for 6 years while gathering a small but living community?

The following points will be discussed:

• making reasonable technical choices
• targeting a niche
• sharing the joy
• surviving the Python3 switch
• building a community
• surviving the bus factor
• finding funding
• not becoming a workaholic

Based on a GitHub repository recording the history of the Unix code from 1970 until today, we look at the most significant elements and milestones of the system's architectural evolution and the lessons we can learn from it.

The Unix operating system has had a profound influence on the development of open source software and associated communities. Many of today's systems trace their code or design to a 1970 unnamed operating system kernel, implemented in 2489 lines of PDP-7 assembly language. This evolved into the Unix operating system, whose direct descendants include today's BSD systems and intellectual heirs form the various GNU/Linux distributions.

How did the architecture of Unix evolve over the past half century? Based on a GitHub repository recording the system's history from 1970 until today, a database recording the evolution of provided facilities, and the reconstruction of the Third and Fourth Edition Unix manuals, we will examine the most significant milestones of this development and the lessons we can learn. Many architectural features, such as layering, system calls, devices as files, an interpreter, and process management, were already visible in the 1970 version. Other ideas followed quickly: the tree directory structure, user contributed code, I/O redirection, the shell as a user program, groups, pipes, and scripting. Later versions added domain-specific languages, environment variables, a documented file system hierarchy, software packages, virtual memory support, optimized screen handling, networking, storage pools, dynamic tracing, and a packet capture library. Based on a record of facilities documented over the years we will see areas in which evolution continues at an unchanged pace and areas where it appears stalled. We will also see how one measure of code complexity has followed a self-correcting path. Lessons we can derive from this amazing ride include the durability of early architectural features, the value of establishing conventions over the imposition of rigid mechanisms, the importance of additions made after the system's gestation, and the increasing difficulty of bringing about ground-breaking changes as Unix ages.

Even a simple typo correction has to travel a long journey from the OpenOffice User Interface to the source code, to the translation team and all the way back into the new release. We will explore the involved process, tools and how the process can be streamlined.

What we see in the modern data store world is a race between different approaches to achieve a distributed and resilient storage of data. Most applications need a stateful layer which holds the data. There are at least three necessary ingredients which are everything else than trivial to combine and of course even more challenging when heading for an acceptable performance.

Over the past years there has been significant progress in respect in both the science and practical implementations of such data stores. In his talk Max Neunhoeffer will introduce the audience to some of the needed ingredients, address the difficulties of their interplay and show four modern approaches of distributed open-source data stores.

What we see in the modern data store world is a race between different approaches to achieve a distributed and resilient storage of data. Most applications need a stateful layer which holds the data. There are at least three necessary ingredients which are everything else than trivial to combine and of course even more challenging when heading for an acceptable performance.

Over the past years there has been significant progress in respect in both the science and practical implementations of such data stores. In his talk Max Neunhoeffer will introduce the audience to some of the needed ingredients, address the difficulties of their interplay and show four modern approaches of distributed open-source data stores.

Topics are:

• Challenges in developing a distributed, resilient data store
• Consensus, distributed transactions, distributed query optimization and execution
• The inner workings of ArangoDB, Cassandra, Cockroach and RethinkDB

The talk will touch complex and difficult computer science, but will at the same time be accessible to and enjoyable by a wide range of developers.

This talk will present some updates on the VideoLAN community and on VLC.

We will notably discuss about VLC 4.0 (the next release); VideoLAN infrastructure, including security; and other projects like VLC.js or VLC-VR.

We will also speak about the status of other VideoLAN software, like libbluray, libdvdcss or x264; and other part of our community.

A crash course to get you up and running with PostgreSQL. We will cover:

• Installation from binaries and source
• Cluster initialization, startup, and session management
• Basic configuration - postgresql.conf and pg_hba.conf
• psql use/hints
• SQL syntax and quoting
• Data types

This talk will demonstrate advanced testing practices used by the XWiki open source project, and using Java, Maven, Docker and Jenkins:

• Testing for backward compatibility with Revapi and an associated strategy
• Testing for coverage with Jacoco and defining a viable strategy for slowing improving the situation
• Testing the quality of your tests with Descartes Mutation testing
• Automatically enriching your test suite with DSpot
• Testing various configurations with Docker containers and Jenkins

A introduction to BulletinBoard, a internet-wide general-purpose distributed-hash-table to store key/value pairs and wireguard-p2p, a tool for setting up WireGuard VPN connections from peer to peer.

Whenever I tried to look through Open Office Code I see the same Issues in Code I see in my consulting work. I would like to go with the Audience through some of the basic Antipatterns of coding. In a presentation I will define those basic Antipatterns. I will give some reasons I have seen in my professional work why they occur and they seem to be true in Open Office, too. In the last phase we will transit into a discussion about how avoid these issues, and how we can reflect on these Issues.

My Idea is to have 15 Minutes Presentation and 15 Minuts discussion. Language will be in english, as good as my english is. :)

The Z Garbage Collector, also known as ZGC, is a new garbage collector optimized for low latency and very large heaps. We've developed ZGC internally at Oracle so far, but we're now open-sourcing it so as to broaden the base of both contributors and users. It was recently accepted as an official project under OpenJDK where future development will be happening.

This talk will give an overview of how ZGC works, how it scales to multi-terabyte heaps and how it maintains very low GC pause times. We'll present the goals, current status and what to expect going forward. We'll also give a quick primer on how to get started using ZGC on your workloads.

Metrics, when used wisely, allow you to make informed decisions about how to grow your open source community and how to better assess its health. But your community is about more than code. Who’s joining and leaving? Who's really active and really helpful? Who should you be encouraging? In this presentation, Jeremy will explain why your metrics should track more than just code. Open source ecosystems are really about people, which is why we're creating a Contributor Relationship Management system.

This talk will describe two python extensions for gdb: @PrettyPrinter decorator — an easy approach to writing new pretty printers for your data, and DUEL — a high level data exploration language, a very powerful but easy way of examining complex data structures.

A presentation of the Open Source IDM server : Keycloak. Some slides to give the big picture followed by a live coding session where we will set up a keycloak server and then secure a front app and some backend ends applications.

The talk demonstrates the Genode-based operating system as routinely used by the Genode developers. The starting point is a generic and fairly minimalistic base system, which is then live shaped into different forms using a plain text editor. Along the way, many features of Genode come into play, eventually forming a usable system.

Over the past decade, the Genode OS Framework has evolved from a research prototype to a practical operating-system foundation. This is evidenced by the Genode developers who use the system day to day. Being a component-based system designed after the principle of least privilege from the very beginning, it breaks with many concepts that we take for granted in traditional operating systems, e.g., the central role of files. Instead, Genode introduces a novel way of composing system scenarios out of building blocks where the building blocks are able to cooperate without ultimately trusting each other.

The composition of Genode systems used to be defined at system-integration time before booting the system. However, Genode also allows completely dynamic compositions where the system's behavior and structure can be changed at runtime. This ability is the basis for the use of Genode as a general-purpose OS. The talk introduces Sculpt, which is the designated blue-print for interactive and fully dynamic Genode systems.

A short walk through of what we have been doing past year since v17 release and what we are still planning to do.

During the time we worked towards the final release of v17 some of our developers already took a head start for v18. During past year developers in and outside of the Kodi Team have been steadily refactoring and working on new features that will be included in the upcoming V18. Various parts have already been published in articles on our website though we will also sum up some parts that are in the pipe line. In total will try to do a brief rundown on what we hope will be included.

Upspin is both a protocol and a reference implementation for a global name space for network-accessible files that comes with permissions and end-to-end encryption. With simplicity at its core (the protocol is just 10 methods), it is very versatile and can be a building block for a decentralized Internet

Last October, Rob Pike published the Upspin manifesto on his blog - command center. This manifesto is centered around a concept I care for: the separation of the producers and the consumers of data. I had been willing to create web services that could freely inter-operate and Upspin is a wonderful tool for that. Since then, I have been working on a collection of Upspin client and servers to prove the concept.

In this talk I will present: - the basic concepts and architecture of Upspin - my implementations of Upspin client and servers (directory and storage) - my thoughts about what can be done with Upspin

Nowadays we have low-level tools to control Open Source FPGAs but these are only for experts who know hardware description languages. There is a challenge in making this technology accessible and easy to use by everyone. In this talk I will present the project Apio, a multiplatform cli toolbox, and Icestudio, a high-level visual editor that allows to create and synthesize graphic designs into Open Source FPGAs. Connecting high-level description languages with real hardware implementations enables a lot of new ideas, new research branches, new capabilities. We have begun to explore the surface but there is still a long way to go!

Flatpak uses unprivileged Linux containers to install and sandbox desktop apps. It resembles traditional packaging systems like dpkg and RPM in some ways, but is very different in other ways. This talk will introduce Flatpak's model for packaging, how and why it differs from traditional packaging systems, and how Linux operating systems can benefit from having both.

Traditional packaging systems like dpkg work with small, granular packages with a web of interdependencies. Flatpak is intended for user-facing GUI apps ("leaf packages"), which each have a single dependency: a "runtime" that collects all the libraries that the app needs and doesn't bundle.

Key topics:

• The problems Flatpak sets out to solve: why traditional packages aren't always a good fit
• How Flatpak mitigates the problems associated with bundled libraries
• Avoiding data duplication and wasted space

This talk is intended for an audience of developers and sysadmins familiar with traditional packaging systems, but perhaps not the details of Flatpak.

The same speaker will be giving a follow-up talk on Flatpak's relationship to distributions, in the Distributions devroom on Sunday.

ONAP (Open Network Automation Platform) is an open source software platform that delivers capabilities for the design, creation, orchestration, monitoring, and life cycle management of

• Virtual Network Functions (VNFs)
• The carrier-scale Software Defined Networks (SDNs) that contain them
• Higher-level services that combine the above

ONAP provides for automatic, policy-driven interaction of these functions and services in a dynamic, real-time cloud environment. ONAP is not just a run-time platform; it includes graphical design tools for function/service creation. This talk will introduce ONAP as a whole and walk through a specific use case (vCPE) from design to VNF onboarding and runtime. Eventually, how we can leverage ONAP to enable open/closed loop automation of Virtual Network Functions.

The initial idea of pot was to imitate containers, like docker, but using FreeBSD technologies, like jails and ZFS. The goal was to run several "pots" on my laptop to serve my needs and, at the same time, to learn how to manage them efficiently, especially in term disk usage. Instead of using/extending existing tools, like ezjail or iocage, I decided to reinvent the wheel and to write myself a new tool. After some time, I realized that making pot more generic and available to everyone could be a good idea and that's what I intend to present. I also show some interesting use cases and, hopefully, a live demo.

Nakadi is an open source event broker, built on top of Kafka-like queues, that provides a REST API for easy integration with microservices. In this talk, we will introduce Nakadi, and demonstrate one of its most important features: timelines.

Timelines is a feature of Nakadi that allows administrators to transparently move queues between different clusters, without interrupting producers or consumers. This is useful to move between clusters, possibly using different technologies, but also as a fail-over for publishers in case of downtime on a cluster. Timelines can also be used to move event types between brokers on the same cluster, which is an alternative to rebalance operations. Contrary to rebalance operations, using timelines does not require additional data copy between brokers, which can slow them down. Future plans include using timelines for re-partitioning, i.e. changing the number of partitions in an event type.

Nakadi is used at Zalando, to produce around 15 terabytes and consume around 40 terabytes of data daily.

I will show the Blockchain analysis in Jupyter interactive notebook using the external Spark cluster running in Kubernetes, everything dockerized.

The talk will briefly describe how Blockchain transactions work, but most of the time would be the demo. In the demo I will show how we can run various queries on the publicly available Blockchain data, graph algorithms such as PageRank for identifying significant BTC addresses and more.

Intended audience: intermediate, analysts, Bitcoin/Altcoin enthusiasts

Hypervisors were once seen as purely cloud and server technologies, but have slowly seeped into the embedded space providing extra layers of security. This discussion will showcase how companies from security vendors to automotive are using open source hypervisors (particularly Xen Project) to secure embedded systems, what challenges they face and how they have overcome it. We will also explore what this might mean to IoT at large and how to get started in securing your embedded system with a hypervisor-first approach.

Hypervisors were once seen as purely cloud and server technologies, but have slowly seeped into the embedded space providing extra layers of security. This discussion will showcase how companies from security vendors to automotive are using open source hypervisors (particularly Xen Project) to secure embedded systems, what challenges they face and how they have overcome it. We will also explore what this might mean to IoT at large and how to get started in securing your embedded system with a hypervisor-first approach.

The topic will cover content such as: * Why virtualisation in embedded * Hypervisor architectures on ARM and a quick roundup of examples * Relevant security technologies * Specific requirements for embedded systems * Example usage of FOSS based hypervisors in embedded * Challenges such as safety certification and how this may be approached

We'll do community karaoke using not much but a laptop and the mic in the room. If you have a song you want to karoke, tell us where you can find the music online and come prepared to sing.

Those who do not wish to sing or listen are welcome to use this time to go have lunch.

In the spirit of Jon Bentley(not the top gear dude), we will take this chance to talk about everybody’s favorite pastime...debugging!

As programmers, we spend most of our time debugging. I know I know, most of us never 'write' any bugs(it's ALWAYS your pesky colleagues). Still, somebody has to clean it all up.

And yet, there's very little literature about debugging. Fewer conference talks still. But that's about to change.

This talk will be a collection of real-life bug micro-mortems. Proving now more than ever, that for want of a nail, kingdoms can really be lost...

The Pixel Format Guide is a collection of documents and an accompanying python tool which aim to help people interpret and manipulate the pixel format definitions used by the various graphics APIs and projects. In this talk we will describe the Pixel Format Guide and the capabilities of the accompanying tool, provide examples of how it can be used to automate many tasks involving pixel format definitions and explore future directions.

Every graphics API and project has its own way of describing and naming pixel formats — the different flavors used by Vulkan, OpenGL, Mesa, Gallium, Wayland, DRM, GBM, Pixman, Mir and SDL are just a few of the beasts one can encounter in the graphics wilderness. The Pixel Format Guide aims to become a comprehensive reference for pixel format definitions used by such APIs and projects, describing aspects as component bit order and dependence on system endianness. The guide provides both a collection of documents describing how to interpret the definitions, and a python tool and library (called pfg) that allows automatic interpretation of pixel format definitions and operations on them. The Pixel Format Guide currently supports 12 pixel format families for a total of 541 format definitions.

The pfg python library allows users to leverage all the information and capabilities of the tool to create their own custom scripts. A prime example of such a script would be the automatic production of code to convert between pixel formats definitions belonging to different format families.

BaseDocumenter will be published (under the GPLV3 license) during the first half of 2018 as an extension/plugin of LibreOffice.

The software scans Base applications (tables, queries, forms, scripts, ...) and collects everything useful to support the application designer and to improve the dialog with the end-user. A special focus is set upon impact analysis, i.e. how to cope with design changes and what-if situations.

SQL and Basic scripts are parsed. An SQL beautifier is also included.

The documentation is made available as a set of static HTML pages. All dependencies between objects ("query X uses table Y", "table Y is used by query X") are made visible by hyperlinks. This makes browsing thru the documentation particularly efficient.

This presentation will reveal the exact steps for making a low-cost lightning solution that combines open source hardware with free and open source software. It will cover a wide range of topics from designing a printed circuit board with KiCAD to software support and integration with the popular open source home automation platform Home Assistant through the machine-to-machine protocol MQTT.

We will review the designing process of open source hardware embedded devices that control 12V RGB LED strips and collect data from I2C sensors for light, temperature, humidity, color and gesture recognition. We will compare and highlight the differences between the software implementation of MQTT client with brightness and color control of the lights using pulse-width modulation (PWM) on embedded Linux through an add-on board for Raspberry Pi and a device powered by the low-cost microcontroller with Wi-Fi ESP8266.

The talk will also provide information about open source hardware licenses, KiCAD getting started guidelines, tips for avoiding common hardware pitfalls and mistakes. Furthermore, we will discuss the challenges of prototyping and low-volume hardware manufacturing. The talk is appropriate for anyone interested in combining open source hardware with free and open source software. No previous knowledge is required. The presentation will try to encourage more people to grab the soldering iron and start prototyping entirely open source products.

The open source hardware movement is becoming more and more popular. In this presentation, Leon Anavi will share his experience how to use free and open source software for making high-quality entirely open source low-cost lighting solutions using 12V RGB LED strips.

Unlike Phillips Hue or IKEA Trådfri, the open source hardware lighting solutions are more flexible and developer friendly. They can be easily integrated with various free and open source software platforms for home automation such as Home Assistant. The practical examples in this presentation will be based on the open source hardware Raspberry Pi add-on board ANAVI Light pHAT available at GitHub under CC BY-SA 4.0 license and a work in progress device with ESP8266. Both devices have 2 layer printed circuit boards made with the free and open source software electronics design automation suite KiCAD. Tips for avoiding common pitfalls and mistakes as well as recommendations for optimization of the SMT and THT assembly with be shared.

Home Assistant is written in Python 3 and runs perfectly on a Raspberry Pi. Out of the box it supports popular mass market Internet of Things such as IKEA Trådfri, Philips Hue, Google Assistant, Alexa / Amazon Echo, Nest, KODI and many more. Furthermore it allows straight-forward integration of other embedded devices that support the machine-to-machine protocol MQTT using the so called MQTT JSON Light component. MQTT broker, such as the open source Mosquitto, is required to distribute the messages in real time among all hardware devices in the lighting solution.

The presentation is appropriate for open source enthusiasts, engineers, students and even beginners interested in combining open source hardware with free and open source software.

This talk will present new data protection and identity governance capabilities of midPoint. MidPoint is open source identity management (IDM) and identity governance (IGA) system. MidPoint has all the features of a traditional identity management system. However, this talk will focus on data protection and identity governance. We will explain what identity governance is and how it can handle the challenges of data protection legislation such as European GDPR regulation. We will show how to use midPoint to set up identity management and governance policies and how midPoint can be used to maintain them in the long run. The talk will show how to manage data protection, entitlements and security policies in one unified system and how to consistently apply that to employees, students, contractors ... and all other identities in all your systems. This talk is intended for identity administrators, security officers and all security practitioners in general.

Overall goal: Overview of midPoint as an open source identity management and governance system. Especially focused on the governance part, as that is very unique in the open source world. Demonstration how midPoint can be used for data protection (e.g. GDPR).

• Very quick overview of midPoint - what it is, a bit of history, etc.
• Basic demonstration of RBAC, role request process, approval and so on. Just few minutes to warm up the audience and get everybody at the same level of understanding of the IDM basics.
• Identity governance: Explanation of how midPoint policy rules and data protection scopes work. How they can be used to set up data protection policies (such as GDPR lawful basis management). Little bit of theory. But mostly practical.
• Short demonstration of the policy set up in midPoint. E.g. show how midPoint can report the problems with GDPR compliance.

MidPoint is a comprehensive open source IDM system. Project is running since 2011 and it is very active: https://github.com/Evolveum/midpoint Katarina Valalikova and Radovan Semancik are both core developers of midPoint.

Expected duration: 40+10min

Today open-source is used in almost any software development cycle. We're able to deliver the best product to our customers faster than ever before. At the same time, nobody wants to sacrifice quality or the pace of production. We know a lot about software quality assurance, and we have tools to produce higher quality software. Could we use them to ensure the quality of the open-sourced solutions as well?A couple of years ago, I created a tool called Ossert. An experiment to asses the quality of every Ruby gem. While developing Ossert, I thought a lot about the quality of the open-source software.

In this talk, I'll talk about my experience in making the quality of OSS measurable: how could it correlate with project maturity stage? The patterns of its community behaviour? Finally, I'll share the set of practices I created to asses the quality of open-source development processes.

Is it possible for non-tech people or even kids to create digital circuits? Thanks to the Icestorm project we all have open source FPGAs. We have develop both Free/libre hardware and software for making it very easy for the non-tech people or kids to start learning and playing with digital circuits. We will show in a demo how the Icestudio and the Icezum Alhambra FPGA board works. With very few clicks the digital circuits are synthesized and uploaded into the FPGA. It opens the way for teaching hardware thinking and digital circuits without pain and learning concepts while building circuits

This talk will take a look at what's been happening in the GStreamer multimedia framework as of late and what shiny new features you can expect to land in the near future.

It will be fairly high-level and is targeted at both application developers and anyone interested in multimedia on Linux and elsewhere.

GStreamer is a highly versatile plugin-based multimedia framework that caters to a whole range of multimedia needs, whether desktop applications, streaming servers or multimedia middleware; embedded systems, desktops, or server farms. It is also cross-platform and works on Linux, *BSD, OS/X, Windows, iOS and Android.

Whether WebRTC, RTP, RTSP, SRT or RTMP, decoding or encoding, streaming or recording, we have it all!

Join us to find out what's new!

The Cython compiler is the most widely used static compiler for Python. It is used to speed up Python code and to extend the CPython runtime with fast native extension modules that process huge amounts of data all around the world. This talk by one of the core developers gives a quick intro into the compiler, the language, and some of its main applications in the Python big-data ecosystem.

Cython is not just a Python compiler or a native code wrapping tool, but also a programming language in its own right that mixes the Python language with C and C++ data types. The fact that you can simply drop Python code into it and compile it gives a very low entry level into performance optimisation by statically compiling your critical code and then tuning it into fast C to make it run faster.

In this talk, I will guide you through some examples where the compilation of regular Python code leads to faster execution, and present ways how to make the code run much faster.

These days, Mozilla is rewriting Firefox's devtools using a new and shiny technology stack. Anyone can join easily - the code is on Github, and it's just a matter of 2 commands in your terminal to get a local debugger running!

The debugger is universal - it can debug any browser, node and mobile. The feature list is innovative and aimed to be the best debugging experience for React, Angular, Ember, RxJS and more types of apps. In addition, making contribution to the debugger together with top notch developers from all around the world is an exciting experience!

By the end of this talk you will have the tools to get into hacking on Firefox's debugger. I will introduce architecture and process of development, and make you feel comfortable to approach a world class open source project, and become a contributor to tomorrow’s JavaScript debugger.

Retrocomputing, lost lessons of software design, a quarter of a century of failed progress - and how learning from the past could lead to the next generation of computers.

There are many now-forgotten OSes and languages that could do things that modern systems can't even approach, but they are long gone, out-competed by inexpensive commodity computers and lowest-common-denominator software. This talk discusses some of that forgotten history, and how what we did instead has landed has landed us with significant problems... and some possible ways that we could escape these problems and find new ways forward.

It will touch upon Plan 9 and Inferno, Taos and Intent/Elate, the Dandelion machines and Mesa, Oberon, OpenGenera, Movitz, ChrysaLisp, Urbit, the Canon Cat, the original Newton OS and Dylan, and more besides. It will also examine the next big transition that we're facing, one that almost nobody has noticed and which existing OSes are ill-suited to handle -- and how learning from the past could help improve the future.

This talk dives into github.com/golang/dep, the “official experiment” and precursor to a new approach to dependency management in the go toolchain itself. To help you get the most out of dep, we’ll cover both the essential workflows, and dep’s core design principles.

This talk will cover the essential mechanics of dep, combined with an explanation of the main ideas behind dep’s design. It makes sense to explain these together, as dep is an opinionated tool with a spare interface: if people don’t understand dep’s basic way of thinking about dependency management, then they may find themselves “holding it wrong,” and having a difficult time. The benefit of dep’s spare design is that doesn’t take long to cover the essentials, and attendees will be able to walk away with a clear sense of how to leverage dep to their advantage.

vSwitches, vRouter, vGateway can be transparently deployed on the hosts of a LAN using VDE based Networks of Namespaces (NoN).

A Network of Namespaces (NoN) interconnects network namespaces running on different hosts as if they were on the same (virtual) Local Area Network. It is possible to set up and maintain NoN using VLANs, veth, kernel bridge definitions,… but it would be a daunting work for system administrators.

VXVDE and VXVDEX implement zero-configuration NoN. Starting a namespace connected to a NoN it is as simple as typing a command like: “vdens vxvde://“. This new approach is fast (about the same performance figures of VXLAN’s kernel implementation) and it runs on vanilla Linux kernels.

Several protection features can be added to support different usage scenarios: VXVDEX provides NoN with access control, and the agnostic encryption (meta) plugin can protect any kind of VDE implementation from eavesdropping.

The world of PostgreSQL replication has come a long way from the days of manually compiling and installing erServer. The options are new, and there are many of them, directed at solving different problems. This talk takes a look at some of the options available today and tomorrow.

There are few things in today’s technology landscape that promise to be more transformational than the emergence of an estimated 20 billion IoT edge devices by 2020.One of the well understood impacts of the edge as it emerges is that it will unleash a data tsunami. The evidence is already out there—a connected car can produce up to 5 terabytes of data hourly, an oil and gas drilling rig can produce 7 to 8 terabytes of data daily. Waiting for all of this data to be sent to the cloud and acted upon won’t cut it for many applications in industrial or consumer domains. Even for edge analytical applications, conventional big data architectures that involve forwarding everything to the cloud to be stored and analysed doesn’t make sense—what you likely need are Machine Learning and streaming analytics capabilities at the edge.

Project Flogo is an 100% open source light weight engine which enables developers in building the broadest open IoT community. Project Flogo functions as one the first design bots for IoT edge application development, with a tile-based, zero-code environment for building and deploying integration and data processing directly onto connected devices. Its design bot and Web-based UI bring the best of TIBCO’s design environments to the IoT, with prepackaged building blocks for building applications, integration, data processing, and microservices, as well as error handling, including the first-ever auto-stepback debugger. Project Flogo brings this power to many of the smallest connected devices, with an average installed footprint that is up to 20 times lighter than Node.js and 50 times lighter than Java.

Tasking in Ada provides an effective tool for shared memory parallelism. For coarse grained regular parallelism, load balancing works with one single job queue. For finer grained and irregular parallelism, work stealing balances the load with multiple job queues. The programming concepts will be illustrated with examples of algorithms in polyhedral geometry. The demonstrated code belongs to the free and open source PHCpack, at https://github.com/janverschelde/PHCpack.

Can you tell exactly which source files are built into your binaries? Any sufficiently large build feels a bit like magic! Join me to explore how you can debug your build by stracing it and rebuilding a build graph of files and tools transformations.

Some applications for this knowledge:

• better control of which subset of the code you use and depend on.
• general build hygiene and debugging such as pruning obsolete or dead code.
• build optimization

And answer some questions such as:

• if a file is really used or not and where it is used and what for.
• how it was compiled and combined
• what are your build dependencies.

I will present a TraceCode, a FOSS tool that uses build-time syscalls tracing to reconstruct your build graph. Using build tracing with strace (disclaimer: I am a small-time contributor to strace ), you capture a complete trace of all the systems calls happening during your build.

The trace is then parsed and processed to reconstruct the build graph of your binaries as a directed graph of files transformations over tools such as code generators, scripts, compilers, assemblers, linkers, etc. This requires NO modification of your build at all.

The graph can then be analyzed for fun and profit, including creating fancy dot graphic visualizations and can help understand exactly which files were built, by what and how they were transformed in multiple steps from sources to your final binaries.

As a bonus, I will also present new FOSS extension that perform similar build reversing but using static analysis only.

Historically, monitoring has been thought of as an afterthought of the software development cycle: something owned by the ops side of the room. But instead of trying to predict the various ways something might go sideways right before release and crafting dashboards to prepare, what might it look like to use answers about our system to figure out what to build, and how to build it, and whom for?

Observability is the practice of understanding the internal state of a system via knowledge of its external outputs -- and is something that should be built into the process of crafting software from the very beginning.

This lightning talk will cover our team's efforts at Bloomberg to run a set of performance tests using Locust, an open source Python-based user load testing tool. The talk will review our motivation for running performance tests, how we set up our testing environment in a distributed fashion so that we can generate a high load, how Locust helps with this, and how to automate this testing process. The talk will also cover how testing can prevent potential risks when releasing new software to your client base.

Brief update on the Nouveau project.

We want to talk about what we have done on over the past year(s) and what we are planning to work on in the near future. Main topics will be power management, Nvidia and community.

The MethodHandle API was added in Java 7, as a way to programmatically build up smart function pointers. Far more powerful than simple reflection, handles JIT and optimize like Java code, producing a fast, direct, type-safe callable. And the API has continued to evolve: in Java 9, you can now embed atomic semantics, array views, loops and "finally" logic, and much more. Come learn how flexible and useful MethodHandles can be!

Installing FreePBX and Asterisk on a general-purpose system has a lot of hidden traps and requires sysadmin skills. But sometimes we don't want to use a specialized distro for several reasons. This talk is about why we have chosen to provide a ready-to-use PBX on NethServer and how we dealt with problems that you face when you try to install cutting edge FreePBX and Asterisk releases on a standard distro (CentOS 7 in our case) that has to work in production environment providing also other services.

Installing FreePBX and Asterisk on a general-purpose system has a lot of hidden traps and requires sysadmin skills. But sometimes we don't want to use a specialized distro for several reasons. This talk is about why we have chosen to provide a ready-to-use PBX on NethServer and how we dealt with problems that are faced when trying to install cutting edge FreePBX and Asterisk releases on a standard distro (CentOS 7 in our case) that has to work in production environment providing also other services. Issues solved are: PHP version required by FreePBX > than CentOS upstream, missing or outdated RPMs, Installation scripts Vs RPMs, backup and restore, HTTPD instance that runs as asterisk user, security issues and keeping kernel modules up-to-date with upstream kernel. After this talk, you'll know how to package and maintain FreePBX, Asterisk and their dependencies for your favorite distro, and how to overcome issues you can usually encounter when packaging webapps.

As we look at the next horizon for FOSS, we must consider who will take us there. While we have these founders in our midst, we must take the time to do succession planning for free and open source leadership.

While sharing of and collaborating on software has been around as long as there's been code, the open source concept and movement only came into being in the late 1990s. There are many who remember a time before open source. Of those, most helped to shape the philosophy, laws, governance, and policies which are the foundation of the free and open source movement we enjoy today.

But what happens when these people decide to retire? Who will carry the baton and lead the movement?

Thankfully these people are still with us, helping to craft and lead FOSS, but there are very few younger individuals among their ranks. As we look at the next horizon for FOSS, we must consider who will take us there. While we have these founders in our midst, we must take the time to do succession planning for free and open source leadership.

This talk will cover:

• Succession planning: what it is & why we need it
• What new leaders must know & learn
• Steps we can take to develop the FOSS leaders of the future

GStreamer is the de-facto multimedia framework used for embedded Linux systems. I will focus on recent improvements relevant to the embedded community. In particular, I'll explain our progress in making it easy to do zero-copy pipelines using DMAbuf to connect all the components of the multimedia pipeline, from V4L2 capture, to OpenMAX based codecs to Wayland or KMS based sinks. I'll also give a short overview of the improvements into the OpenGL stack, in particular for embedded platforms.

GStreamer is a highly versatile plugin-based multimedia framework that caters to a whole range of multimedia needs, whether desktop applications, streaming servers or multimedia middleware; embedded systems, desktops, or server farms. It is also cross-platform and works on Linux, *BSD, Solaris, macOS, Windows, iOS and Android.

This talks targets everyone who cares about Free and Open Source multimedia on embedded systems. GStreamer is the standard multimedia framework, not only on the Linux desktop, but most importantly, in embedded Linux products.

This talk will explain the tight relationship between the OpenStack and OPNFV communities, using as a base the Cross Community CI project, and the benefits that both communities get from it.

Initially the OPNFV CI was based on the consumption of stable artifacts, including stable versions of OpenStack. Developers were not able to work with master versions, causing lack of testing and delay on delivering projects.

Cross Community CI project (XCI) enabled testing based on master versions of the different upstream components (OpenStack , OpenDaylight...). This caused to significantly cut the time of development and identify bugs earlier.

In this talk we will introduce that concept, and we will also explain the tooling used to achieve it (bifrost, openstack-ansible, ansible-opendaylight), showing how a deployment goes from end to end, how to reuse this project for your own needs, and how to start integrating your own project into XCI if that fits into the scope.

CBSD is able to manage bhyve, jails and xen on a cluster of hosts while keeping dependencies reasonably low. It is able to configure network interfaces and firewall rules dynamically, whether you use PF, IPFW or IPFILTER. This talk will cover main CBSD features, implementation details, future plans and growth of CBSD as well as ecosystem around it.

Management of Xen, VMs and jails on FreeBSD becomes increasingly tedious job especially with technologies like ZFS and VNET (just to mention few) which add on the number of alternative ways one can run FreeBSD based infrastructure. Combining that with multiple options for a firewall and the requirement for VMs to connect to jails and vice verse, makes FreeBSD very versatile. It is also very hard to choose the right set of tools. CBSD strives to unify management of jails and VMs while not taking away any options, and keeping UI and code simple as possible.

Unikernels have been shown to provide incredible performance benefits, including boot times of a few milliseconds, low CPU utilization, throughput in the range of 10-40 Gb/s and memory footprints of a few MBs or even KBs, to name but a few metrics. The clear downside is development time: it can take several months or longer to produce a working, optimized unikernel, and up until now, the process needed to be repeated for each target application. There was no shared research and development on the building and creation of unikernels.

In this presentation we will introduce Unikraft, a new, open source Xen Project sub-project under the auspices of the Linux Foundation that seeks to automate the development process for unikernels. Unikraft decomposes operating systems and libraries into elementary modules called libraries (e.g., schedulers, memory allocators, drivers, filesystems, network stacks, etc) and then allows users to quickly pick and choose, through a menu, which components to use when building a unikernel. Once done, Unikraft builds one image per target “platform” (e.g., Xen, KVM or Linux user-space), severely reducing unikernel development time. We will show a brief demo on how to use Unikraft, and cover the basics of the system including how to contribute to it.

We have spent quite a bit of our time over the last few years developing unikernels – specialized virtual machine images targeting specific applications. We have been particularly interested in them since because of their fantastic performance benefits: tiny memory footprints (hundreds of KBs or a few MBs), boot times comparable to those of processes, and small migration times, to name a few metrics.

Despite the fact that this work and work from several others is proof of their potential, unikernels have yet to see massive adoption. One of the main showstoppers is development time: for instance, developing Minipython [4], a MicroPython unikernel, took the better part of 3 months to put together and test. ClickOS [5], a unikernel for NFV, was the result of a couple of years of work. What’s particularly bad about this development model besides the considerable time spent is that each unikernel was basically a “throwaway”: every time we wanted to create a new unikernel targeting a different application, we would start more or less from scratch.

One thing we did do to try to re-use the work a bit more was to create a separate repo consisting of a “toolstack” that would contain functionality useful to multiple unikernels, mostly platform-independent versions of newlib and lwip (a C library and network stack intended for embedded systems).

That got us thinking that we should take that a (much bigger) step further: wouldn’t it be great to be able to very quickly choose, perhaps from a menu, the bits of functionality that we want for a unikernel, and to have a system automatically build all of these pieces together into a working image? It would also be great if we could choose multiple platforms (e.g., Xen, KVM, bare metal) without having to do additional work for each of them.

The result of that thought process is Unikraft. Unikraft decomposes operating systems into elementary pieces called libraries (e.g., schedulers, memory allocators, drivers, filesystems, network stacks, etc.) that users can then pick and choose from, using a menu, to quickly build images tailored to the needs of specific applications.

This is a real life story of a mixed criticality system, where a proper usage of Ada's features for controlling visibility allowed a provable enforcement of the segregation rules at compile time: any violation would simply not compile.

The Qt Automotive Suite solves a number of automotive problems, but these are not unique to our industry. We have a look at how to measure and understand start-up timing and performance, how to use the Qt Application Manager Wayland compositor, how to generate platform APIs and more. We also take a quick look at the tools provided, e.g. QMLLive for rapid prototyping and GammaRay for deep introspection.

The Qt Automotive Suite is built on top of the general Qt framework and takes Qt from an app creation framework to a platform creation framework. It consists of both tools and libraries.

We see that the QMLLive tool is enjoying usage outside the automotive space and hope that the other components will find users outside of the industry as well. Come here to learn what we do and why.

Making a browser fast will speak about the numerous changes that happens under the hood of Firefox during 2017 and how Mozilla made his browser much more reactive to the user.

This presentation will explain how a browser works, then go into more details about: - Quantum Compositor - Quantum Style (Stylo) - Quantum Flow

and will explain in details some of the major changes that happens under the hood of Firefox during 2017.

Creating and managing network devices, Traffic Control, routing and iptables, introspecting and manipulating network packets. That normally involves a lot of low level C programming, which introduces a huge gap between frontend (web and service oriented) and backend needs (systems programming). Go is excellent in bridging this gap in general, and thanks to the great work of the Go community, networking tasks are very easy to solve too. This session will introduce a set of libraries which form a comprehensive Swiss Army Knife to tackle almost any network related task on Linux with Go.

The talk will present G-CORE and its most striking features. G-CORE is a graph query language proposal developed by Linked Data Benchmark Council (LDBC). It is a closed graph query language that includes graph pattern matching, inclusive extended regular path expressions, graph construction (graph projection and graph aggregation), and (weighted) shortest path finding. The query language queries graphs and returns a graph. Hence, it supports views and correlated sub-queries, which have proven their worth in the relational databases. To ensure that the query language is practically usable on large data, G-CORE builds on previous complexity results and carefully select useful features, but restricted in such ways that the resulting language is polynomial in data complexity. As such, G-CORE connects the practical work done in industrial proposals with the foundational research on graph databases; in fact, it can be considered as a bridge between these two worlds.

The Chips4Makers project tries to make low volume ASICs possible for makers and hobbyists. The talk will start with a summary and vision of the Chips4Makers project.

In a second part of the talk the current state of the used tool chain will be discussed. With the Retro-uC project this tool chain is tested and it will be presented what worked and what is candidate for improvement. I do hope I can get feedback from the public and get more inspiration to improve the toolchain in use for future user projects.

The Retro-uC chip itself - a microcontroller with the right instruction set for a retrocomputing enthusiast - is discussed in a talk in the retrocomputing devroom.

This talk will take you through the basics of a11y in a desktop application, using LibreOffice as an example. Starting with basic terminology (mnemonic widget? accessible label?), we'll discover building blocks of a11y in desktop environment, have a look at the sources of most common mistakes developers make when they don't include a11y-awareness into their development process and how to fix them. We'll also show the ways how anyone (even those with little or no knowledge of programming) can contribute to improving a11y ... not only in LibreOffice.

Spack is a general-purpose package manager, used on machines ranging from laptops to high performance computing (HPC) clusters. It supports packages in C, C++, Fortran, as well as many other languages, and it allows users to build many different versions of packages with different compilers, build options, dependencies, patches, and target architectures.

Swapping a new compiler into a build may seem trivial, but this and other features in Spack add subtle constraints and complexities to the dependency model. We'll talk about modeling compiler runtime libraries in the DAG, compilers depending on other compilers, and how dependency resolution has to change for cross-compiling. We'll also touch on why all this is necessary for HPC environments, and how packaging has helped to enable new collaborations and software reuse across the scientific computing community.

SaaS are for a lot of us an unavoidable part of our day to day workflows. Unfortunately, sometimes things goes wrong and you need an hand from the support team to get you back on track.

This talk will explore how, as a SaaS provider, you can implement an access to independent customer instances for your support staff and guarantee accountability and auditability using only free software tools like HashiCorp Vault.

A rough outline of the talk would be: * Challenges of doing support as a SaaS provider in terms of access management * Evaluation of solutions and their shortcoming * Introduction to the secret manager tool HashiCorp Vault * Implementation of a solution that guarantee accountability and auditability. There will be a bit of PKI and Golang. * Live demo using the myTuleap cloud service as an example

During the history of digital computers, the majority of mainstream computer systems we designed as CPU-centric. All the data that the computer processed always passed through the main memory in one way or the other and the code running on the CPU manipulated with the data, directly on indirectly. Even DMA controllers, co-processors, GPUs and intelligent NICs were used just as slave peripherals, although with some degree of computational off-loading in the recent years.

One of the reasons for keeping the same basic architecture despite its drawbacks such as the ever-widening memory barrier (i.e. the difference between the latency of the CPU and the RAM) was arguably its conceptual simplicity. However, trends for a major change in the status quo are finally emerging into the mainstream. These new architectures, often called data-centric computing or near-data processing, propose to turn an ordinary computer into a distributed system where the distinction between the CPU, main memory and peripherals is much more blurry. Components such as individual DRAM chips, flash memory chips and NICs should have autonomous computing capabilities and the possibility to interchange data between other components without the involvement of the main CPU.

This talk will present a brief overview of the concepts and discuss the consequences for operating system designs, especially regarding microkernels.

The internet has failed to decentralize. What started as a network of nodes in people's homes turned into a network of server farms largely owned by a handful of tech giants. Flaws in the internet's design and implementation allowed for an online world to form where a few large services control nearly all users. Social networks don't put you in touch with your friends. They put you in touch with a server that helps with that... at the cost of privacy and community.

Urbit aims to solve this and many other problems by providing a decentralized network of personal servers. These come with a personal identity and an operating system that provides an immutable global namespace and all the infrastructure needed for making decentralized applications.

The internet has lost its way. What was promised to be an open cyberspace where digital communities could form and flourish has turned into a landscape of unmovable monoliths. It may not have wanted this, but flaws in the design of its infrastructure and software set it up to fail.

Security is hard, but the defaults aren't helping. Without diving into often complicated configurations and the inner machinations of your system, the best you're going to get is an unencrypted connection and passwords stored in plain text. Sysadmins can do this. Your parents probably can't.

Social networks don't put you in touch with your friends. They put you in touch with a server that helps you talk to your friends. It's difficult to form cohesive communities when you see everyone through a filtered stream of data, rather than getting to exchange content directly.

Wheels are being re-invented over and over again. WhatsApp, iMessage, Facebook Messenger, Telegram... can you still tell them apart? They fulfill nearly the exact same purpose, using practically identical interfaces. Why can't I message my friends on Twitter using Signal?

Everyone has a ton of accounts for all kinds of redundant services. You're just one person, and yet you're forced to juggle many different online identities. Password fatigue is at an all-time high precisely when people need to start caring more. Software isn't helping them care.

Trolls and spammers have no problem with creating many different identities though. They do their thing, and if they get banned, they just spin up a new account to continue their shady practices on.

What if the internet had been built with good, secure defaults? What if machines on that network could talk directly to each other, without requiring a sysadmin skillset? What if there was a general-purpose software stack for communication between individuals? What if everyone had their own, personal address on the network? What if the barrier to entry was just high enough to keep spammers out? What if we had Urbit?

Urbit is a re-imagining of the internet. It paves over all our existing infrastructure and builds its own brand-new stack on top of it, solving the problems it has seen arise at the root. In doing so, it aims to deliver generic infrastructure for a decentralized network of personal servers to grow on.

The Urbit virtual machine runs a sort of assembly language called Nock. Nock is so simple, its official specification fits on a t-shirt.

But just like nobody is expected to write raw assembly, nobody is expected to write raw Nock. Urbit has invented Hoon, a vaguely Lisp-like functional programming language. Though its syntax may seem alien at first, this up-front complexity is the price it pays for semantic simplicity. When it comes down to it, Hoon is quite a dumb language. It has recently been deemed mature enough to be handed off to the community for further development and maintenance.

The Urbit operating system, Arvo, is implemented entirely in Hoon. It uses a handful of kernel modules to give rise to a functional, decentralized network of personal servers. At all times, the state of these servers is the sum of all events they have ever received.

Arguably the most important of the kernel modules is Ames, the networking module. Packets it sends are encrypted by default, only readable by the intended recipients. The network it creates is hierarchically ordered, with higher-order nodes being responsible for peer discovery and software updates for their children. In the event a parent's child misbehaves, it can get kicked out. In the event a child is unsatisfied with the service its parent provides, it can find another node willing to adopt it. This way, digital cities can form. Not around centralized servers, but around communities on the network.

All of this already exists. Urbit is very much a functional piece of software. Though still operating on a testnet, it has managed to gather a vibrant community of users and developers alike who are fed up with the ever increasing centralization of the internet.

It's not yet ready to replace the internet, however. Things will start off a bit smaller than that. Urbit is starting to prove itself very useful for API aggregation: managing and mirroring all your existing online identities in one single place. Eventually, this can seamlessly transition into using Urbit's generic, decentralized messaging bus instead of the traditional services themselves. Personal publishing is another application you can use your Urbit for. People are already hosting blogs on their Urbits, and incoming changes are going to make this even better.

The internet has lost its way, so let's build it right this time.

The LTTng kernel and user-space tracer can help solve a wide variety of problems (especially those hard to reproduce ones). There are four main ways of extracting and processing an LTTng trace, and each of them addresses a different use-case. In this presentation we will demonstrate these modes and present real-world situations where they can be used. If you already know how to use LTTng you will learn new ways this tool can help you, and if you don't, you will probably discover a new way to address these complex problems.

The modes we will demonstrate are: post-processing mode (default), snapshot mode, live mode and the new rotation mode.

All of these modes have their pros and cons in a context of monitoring and cloud and we will be happy to discuss with the crowd to see how to address
their particular use-cases and help them gain a full-system insight.

The intended audience is devops engineers having to deal with complex problems and look for a way to scale their monitoring and debugging method on a small or large fleet of servers.

Here is a summary of the modes we will demonstrate and their main use-cases:

- post-processing mode (default): gather as much data as possible and take
  the time to investigate (debugging, logging);
- snapshot mode: when an error is detected, extract the last trace buffer
  from memory (fault investigation, sampling, low impact monitoring);
- live mode: continuously monitor a stream of events (logging, monitoring);
- rotation mode: periodically, or on a specific trigger, process a chunk of
  trace without stopping the tracing (monitoring, logging, archiving
  sampling).

Accessibility in free software has been much improved between 2004 and 2009 thanks to Sun, which massively invested for it. Since it has disappeared, big free software projects have experienced many regressions in this matter. Some of their maintainers consider that there is not enough money to deal with the matter.

Given the complexity of code such as Libreoffice, and given the status of accessibility of software in modern society, it becomes impossible to invest millions of euros to pay for someone who would fix current bugs and track future ones in millions of code lines, through hundreds of commits, and permanently. All the more since beyond this task, a paid expert should rather work about improvements of assistive technologies themselves and pipes (at-spi, atk), instead of fixing miscoding of unaware developers. So, to hope a free and accessible software, major projects need to take responsibility of this. Non-regression tests could be a way to make this duty lighter, even if not a complete solution. What kind of tests could be set?

There's an old joke about a new bride who prepares her first big dinner for her new husband. She's making her mother's brisket recipe which starts by cutting the ends off of the roast. Her husband asks her why she cuts the ends off. She says she does it because that's the way her mother always did it. She asks her mother and her mother says "That's the way your grandmother always did it". She asks her grandmother and her grandmother says "That's the only way it would fit in my pan". There's a lot of folklore and myth surrounding Java garbage collection performance, most of which is obsolete, irrelevant to your application, or was never really right in the first place.

So how do we evaluate a GC algorithm? We can measure various metrics: end to end run time, maximum pause time, average pause time, percentage of the cpu given to the Java threads, memory footprint, micro benchmarks, ... This talk will focus on ten (give or take) metrics/tools we can use to evaluate garbage collection performance. This isn't a comparison of OpenJDK collectors, it's a discussion of what characteristics are important in a good garbage collector and how to measure them.

strace is a diagnostic, debugging and instructional utility for Linux. It is used to monitor and tamper with interactions between processes and the Linux kernel, which include system calls, signal deliveries, and changes of process state. In this talk the maintainer of strace will describe new features implemented since FOSDEM 2017.

In 2017, several interesting features were implemented within strace project, including * syscall specification improvements: new syscall classes, regular expressions, conditional expressions; * detailed parsers of netlink protocols; * advanced syscall filtering syntax; * advanced syscall tampering and filtering with Lua; * asinfo: advanced syscall information tool; * gdbserver backend.

In this talk the maintainer of strace will describe these new features and demonstrate what kinds of problems they help to solve.

A review of the progress of, and plans for the Mir project.

After Canonical dropped support for Unity8 priorities for the Mir project changed. While Canonical's professed interest is in IoT there is potential for Mir to be used by others.

This meeting starts with a presentation of the work done to support such projects and seeks help in setting priorities for future efforts.

It's true, community isn't marketing. But we should adopt and adapt good ideas when they have the power to make us more effective.

In this talk I'll look at how both non-commercial and commercial developer communities can use some of those ideas from the world of marketing to create, implement, measure and report on a strategic plan that provides a clear path from newcomer to community leader. Not only that, I'll also show how to measure and then report that effectiveness to commercial sponsors and the community itself.

There are three great lessons we can borrow from our friends in the marketing world:

• Have a strategic plan.
• Measure, measure and measure again.
• It didn't happen unless you told someone.

It's true, community isn't marketing. But we should adopt and adapt good ideas when they have the power to make us more effective.

In this talk I'll look at how both non-commercial and commercial developer communities can use some of those ideas from the world of marketing to create, implement, measure and report on a strategic plan that provides a clear path from newcomer to community leader. Not only that, I'll also show how to measure and then report that effectiveness to commercial sponsors and the community itself.

If there's a FOSS community that you love and you want to see it become more effective, come and join me in the community dev room.

Open source electronics is only useful if you actually know how to make and assemble a given design. In this lightning talk Kaspar will walk through the build of an electronic circuit assembly: from ordering or making the board, getting the parts and soldering them on to get to a working project.

Developed by a huge community of developers and users, Firefox is one of the biggest software ever created.

In every release, a crazy number of patches (~8000) lands into the code base. The changes can be C, C++, Java, Rust, Javascript, XML, HTML, CSS, etc.

In order to avoid regressions, over years, Mozilla created a number of tools, method and process to make sure the release in a good shape at release day.

This talk will present the various strategy deployed to reach the best quality possible. We will present a wide range of techniques like manual QA, automated tests, code coverage, static analysis, fuzzers, crash detection and managements, etc.

Tor has become a popular choice for privacy-oriented services such as the Debian project or Tails. Unfortunately, not many package management systems integrate Tor. In this talk, we will try to address this issue as we will walk through Tor-aware setup using pkgsrc from NetBSD. You will learn how to "go under the radar" when building packages from source and installing binary packages from your own hidden service.

GStreamer is a framework to develop multimedia applications such as media players, transcoders or video editors. Recent GStreamer releases gained new tools making it easier to debug and gather data about the running pipeline.

In this talk I'll present GStreamer's tracing system and existing tracers (from gst core and third party such as gst-shark). I'll show how GStreamer's leak tracer can be an easier and faster alternative to Valgrind to track memory leaks in your GStreamer application. I'll also present my new log parsing library, written in Rust, to very easily extract and process data from GStreamer's log system.

In a number of workloads, primarily of analytical nature, several parts of postgres' query execution are limited by CPU speeds. One way to address that is by allowing queries to be processed by more than one core at a time; which the project started to enable with 9.6, extended a lot in version 10, with significant additional features expected in 11. But that does not address the efficiency / economics of overall query execution.

This talk will focus on increasing the efficiency of query execution by just in time compiling parts of queries. That is, instead of having roughly interpreter like code to execute the queries, emit native code doing precisely the work needed for a specific query.

The current goal of the project is to use LLVM to perform JIT of two main parts of query execution:

• expression evaluation (WHERE clause, aggregates, GROUP BY clauses, etc)
• tuple deforming (converting on-disk tuples into a more efficiently accessible in-memory representation)

and to integrate as much of that work as possible into PostgreSQL 11.

We'll discuss:

• how the above parts of the system were identified as the primary bottlenecks
• how JIT compilation can help resolve them
• which structural changes to postgres were required to allow for JIT compilation
• how JIT compilation is currently implemented, including the current development state
• the problems faced using LLVM for this task, and which improvements to it could make it better for the use-case

Depending on the available time, we'll also discuss possible future avenues for optimization.

Nowadays one of the most powerful and used OS is also a pain for the developers. Too many devices and customizations makes the management of your app in production a very tough job: users are increasingly demanding, and time to market is required to be at flash speed. How to manage all this madness? How to get information of a particular device that you don't own in order to reproduce the problem and fix it? Is there a global solution? Well, we'll share our experiences gained with an application that is distributed to more than 40000 users, and we'll show some interesting cases we faced with.

Our intent is to share some problematic situations we got developing an android application for a home automation product. In particular we faced issues concerning the following fields: real-time audio/video performances, networking, mobile network operator reliability, device customizations. Often the issues comes from Google market reviews, making very hard to reproduce the same context of the user (device owned, application's set, space available on flash etc..). For each case, we will show the problem, how we faced it and how we solved it using tools and strategies refined with on the field experience.

Contract-based programming is a software development technique, where you include assertions of program properties as a part of the compiled source text. In the strict form, the assertions are checked at compile-time, but in this presentation I will focus on the more common, less strict, form, where at least some of the assertions aren't checked until run-time. Ada gives us a lot of help, so we can write the our assertions about the program properties once, and then have the compiler insert actual run-time checks wherever there is a possibility that the assertion is violated.

This presentation will focus on how we can write these contracts in Ada in a way that make them effective at ensuring that our source text does what we intend it to and allow the compiler to generate efficient checks of the assertions. The intended audience is anybody with enough programming experience to know concepts like types, encapsulation and packages. Having tried to write Ada before will be a benefit, but it isn't a requirement.

The empty interface (interface{}) is one of the most interesting, powerful, and easily abused features of Go, but there are use cases for which it is uniquely and excellently suited. In this talk for the Go devroom, I will propose a set of rules which can be used to see if your use of interface{} will be the elegant and simple API that interface{} promised, or merely lead to a maintainability nightmare down the road.

This talk presents the different challenges Mozilla faces when deploying web services for millions of users, and how load testing is used to prevent the most common pitfalls, through the usage of Molotov.

Molotov (http://molotov.readthedocs.io/) is a custom load testing tool the Mozilla QA team created and uses to stress applications that get deployed for Firefox.

This talk will present the following:

• the different types of applications Mozilla deploys in the cloud
• the most common bottlenecks and how to detect and correct them
• the existing load testing tools
• Molotov features and examples
• Continuous Load Testing principles

By the end of the talk, attendees should have a good understanding of how an application should be stressed.

In a few years time, it will be impossible to study the history of retro-computers since its software was either proprietary, closed-source, written in a now-obsolete language, or encumbered by software “protection” to prevent copying. Furthermore, the hardware upon which it ran is dying, and the cassette tapes holding the software are physically disintegrating.

This talk covers a ten-point plan outlining the primary issues in digital archaeology. It covers the methods necessary to preserve our computing legacy, the use of emulation, and how open source can help with this endeavour. We end with an overview of some projects that will inspire you, and help you preserve your own slice of history!

With the evolution of integrated circuits (ICs), 3D integration is becoming a short and middle term viable solution to increase the system performance, functional density per unit area and reduce system power, as an alternative to costly sub 7nm CMOS technologies. However, as trendy as it may turn, there is no viable Electronic Design Automation (EDA) toolchain that allows to design ICs in 3D. Our work aims at developing tools that could be used in standard 2D EDA chains to deal with 3D ICs. Such tools will automatically transform any 2D design into an optimized 3D architecture by extracting a graph from the DEF file coming out from 2D synthesis and place&route flow. Afterward, this graph can be partitioned automatically using state-of-the art graph partitioning tools.

In order to create the toolchain, we developed a custom DEF parser to answer specific and limited needs that existing solutions such as Verilog-perl or PyVerilog did not allow. The software scans the DEF to find all the gates, pins and nets in the given design. When analyzing nets, it also parses the routing information to determine the total length of the net, which will be needed in the partitioning phase.

In parallel with the DEF parsing (design input), the LEF technology file (technology input) is also parsed to fetch the characteristics of the gates that will be used later on in the clustering and partitioning steps.

Once the design has been parsed, it can be clusterized to reduce the problem complexity and the output is formatted to extract the underlying hypergraph. The extraction makes use of standard Python structures such as dictionaries in order to quickly find links in the design and establish references between the vertices (i.e. clusters or gates) and edges (i.e. nets). When building the hypergraph, some metadata are linked to each vertex/edge (e.g. area, power, total length, total connections) to later set their weights that will be needed in the partitioning phase.

As soon as the design has been converted into a hypergraph, it is formatted in such a way so that it can be fed to the hMETIS package. Using the weights sets extracted during DEF/LEF parsing phase, hMETIS partitions the graph. The output is processed into TCL directives that are then interpreted by a proprietary tool handling the 3D P&R, or they can be used to automatically partition the post-synthesis gate-level netlist and thus be used with any EDA flow, including the open-source ones.

Quentin Delhaye, Dragomir Milojevic, Université libre de Bruxelles, Brussels, Belgium

If fixed function appliances are going to be replaced and complemented by a mix of physical and virtualized appliances, the manageability and service assurance capabilities need to remain consistent or improve on what is available today. The ability to monitor the Network Function Virtualization Infrastructure (NFVI) where VNFs are in operation will be a key part of Service Assurance within an NFV environment.

It is vital to monitor systems for malfunctions that could lead to users' application service disruption and promptly react to these fault events to facilitate improving overall system performance and user experience. The relevant events and metrics must be reported to higher level fault management systems, to detect violations (and enforce SLAs), as well as faults or degradation in the performance of NFVI resources.

Additional statistics facilitate more resilient and performant telco/NFV clouds. By exposing system statistics to collectd, there is more data available, which can be used for monitoring, performance analysis, fault detection, failure prediction, etc. using OPNFV, action can then be taken to negate the effects of any faults in the deployment.

This talk will include: - a short overview of the Barometer (NFVI Service Assurance) project in OPNFV - A demo of how quickly you can start monitoring the NFVI with Barometer. - How OPNFV and ONAP are taking these changes on board

Despite platforms like GitHub & co, several hurdles remain for wannabe contributors, on top of whatever skills were required to puzzle together the contribution, especially for people that are not software developers themselves. Examples include:

• minimal experience with the VCS used by the project (Git, Mercurial, ...);
• some familiarity with the platform where the project repository is located (GitHub, GitLab, Bitbucket, ...);
• being aware of the project-specific contribution policy (for example feature & target branches, how to ;

Although these hurdles can be overcome with a reasonable amount of effort, for example by reading the project's documentation or following some basic tutorials, they turn out to be a showstopper for some people. Possible reasons include:

• limited interest in getting familiar with all required details, especially for first-time or infrequent contributors;
• a lack of time to learn how to overcome these hurdles;
• becoming demotivated quickly because of problems encountered while following the contribution process;

This can result in a significant amount of (potentially very useful) lost contributions...

In addition, project maintainers often lack the time required to process all incoming contributions. Doing so not only requires a visual review of the code changes, but also testing, enforcing code style requirements, providing feedback, etc.

In this talk, I will outline the extensive GitHub integration that has been implemented in EasyBuild, a framework implemented in Python for building and installing (scientific) software on High Performance Computing (HPC) systems.

The EasyBuild command line interface has been extended to add support for:

• previewing pull requests by comparing with current state of the project repository;
• fully automatically creation of new pull requests (covering both the Git workflow & GitHub interface);
• updating existing pull requests to resolve problems or implement suggestions made by maintainers;
• testing contributions by pulling in the changes from GitHub for local testing;
• uploading test reports back into pull requests to efficiently communicate whether the contribution works on other systems;
• reviewing pull requests by cross-referencing with existing relevant files (if any);
• merging pull requests after checking that all requirements are met (approval by Travis CI, successful test report, visual review by a maintainer, correct target branch, milestone set, ...)

In addition a bot was implemented to automatically notify contributors & maintainers that the Travis CI build for a pull request is failing (which is not supported by Travis CI itself).

These features have been implemented by leveraging the GitPython library, the GitHub REST API, and the Travis CI API.

They have proven invaluable for both contributors (regardless of experience) and EasyBuild maintainers, by streamlining the contribution process. In addition, this has resulted in:

• significantly reduced effort to contribute (even for experienced contributors);
• an increase in contributors & contributions;
• better consistency in contributions;
• less time spent by maintainers to process contributions.

I hope this talk can motivate other projects (large & small) to implement similar features to simplify their contribution process, since this is a critical part of building a community around a software project. The EasyBuil features that are outlined can also be implemented in other projects, regardless of the programming language being used and the scope of the project.

Samba Active Directory is now battle ready for enterprise identity and access management.

We want to share with your some stories of how Samba Active Directory is used daily on large setups with many hundreds or thousands of users and PCs.

You'll discover that the thing is used in Ministries, large universities, research center, state governments ... even central banks !!

Our aim is to inspire you to take Samba-AD back home with you and make it an ingredient of your own success as enterprise identity managers.

Past, present, and the future of LibreOffice's Customize dialog.

You can customize menus, toolbars, context (right-click) menus and keyboard shortcuts in LibreOffice, add new menus and toolbars, and assign macros to events.

In the past, the Customize Dialog was providing many ways to change how LibreOffice looks and behaves, but it was not very usable, and it was in need of a revamp. Starting with GSoC 2017, we started a journey to modernize the Customize dialog to make it more usable, fully accessible, and less buggy.

I will try to present a summary about the journey so far, and the plans for the future.

Software Defined Networking seems to be a natural fit for virtual data centers. Centralized management along with flexibility and speed of provisioning are traits of both virtualization and SDN. The oVirt team aims at making this a reality with OVN, a new network virtualization extension to Open vSwitch. The integration is accomplished by the "network provider for OVN", which uses OVN through an OpenStack Neutron-like API, allowing the use of OVN through Neutron abstractions. This concept is already being used in the oVirt project, and there's work in progress to implement it in the ManageIQ project

The session will look into utilising Software Defined Network concepts in a virtualization project through the oVirt perspective.

The presentation will consist of 4 parts: - What is SDN and OVN - Overview of the network provider for OVN - Overview of how the provider is used in oVirt - Live demo: OVN in oVirt

We recently released a graph algorithms library for Neo4j.

You can use these graph algorithms on your connected data to gain new insights more easily within the transactional database and to improve query results from your graph data, for example by focusing on particular communities or favoring popular entities.

We developed this library as part of our effort to make it easier to use Neo4j for a wider variety of applications. Many users expressed interest in running graph algorithms directly on Neo4j without having to employ a secondary system.

We also tuned these algorithms to be as efficient as possible in regards to resource utilization as well as streamlined for later management and debugging.

In this session, we'll look at some of these graph algorithms and the types of problems that you can use them for in your applications and the implementation choices we made.

With JEP 317: Experimental Java-Based JIT Compiler it is very likely that Graal will be part of JDK 10. In fact, Graal is already available in JDK 9 due to JEP 243: Java-Level JVM Compiler Interface. Graal is itself written in Java and that brings some new properties and behavior to the table which we haven’t seen with existing HotSpot JIT compilers. This talk will show how to use Graal with JDK 9, how to compile an upstream Graal version and what to look out for when using it for benchmarking or even in production.

Ppci is a compiler written entirely in Python. This allows for easy compiler development, portability and installation. The compiler is able to process C code into WASM, WASM into xtensa code, but there are more possible code paths. During this session a demo will be shown on how to compile some webassembly to the riscv platform.

The ppci project was started by the need for a better system level programming language then C. The compiler is implemented in python, and hence is not very fast. On the other hand, the compiler is portable and is easier to develop due to being implemented into a higher level language. Currently it supports msp430, x86, xtensa, avr, arm, open risc and stm8 computer architectures, in various levels of maturity. The supported languages are C3 and brainfuck. Language support for C is a work in progress.

The C3 language was the starting point for the compiler, aiming at being a better version of C. It has no header files, but features a more modular approach like C# and java. Furthermore its syntax is context free, making it easier to parse using standard compiler tools.

The backend of the compiler consists of a code generator featuring both instruction selection and register coloring algorithms. The output of the compiler is an instruction stream, which can be serialized as text or in binary form.

Possible uses of this library are:

Compile code and include it into the currently running python instance
Create ctypes bindings for C code by making use of the C parser frontend
Create a programming language using ply/textx and generate machine code from it using ppci

During this session, we will explore the various parts of the ppci library and have a good overview what it is capable of.

pkgsrc (the NetBSD package collection) supports more than a dozen platforms. On a Chromebook in Dev Mode, you can install "arbitrary" Linux software. Obviously, pkgsrc is the perfect fit for that!

However, things are not quite as easy. First, you must get a C compiler, and then there are a lot of idiosyncrasies on the platform. This talk gives an overview of how to get started, and shows the grossest hacks I had to do to get a working pkgsrc setup.

Doing something controversial? Have lots of stakeholders with conflicting needs? Changing course in a way that makes people suspicious or concerned? Write an FAQ! If you can answer the hard questions publicly, honestly, and confidently, you’ll foster trust and build good will even when your audience does not hear the exact answers they want. What’s more, the feedback will give you the input you need to correct any errors you have in fact made. We’ll use real world examples to look at some best practices, including Sun’s comprehensive FAQ for open sourcing Java.

Perhaps you’re in a company, trying to engage developers, leverage the FLOSS development model, and participate in communities important for your business. Maybe you’re part of a developer community eager to further your progress, and intent on changing your contract with contributors and downstream users. When you’re in the development and FLOSS world, inevitably you’ll have complicated, controversial, or unpopular news to deliver as things move forward, and skeptics ready to believe the worst! A comprehensive, transparent, honest FAQ document can help in ways you might not expect.

In this talk, we’ll look at how to use an FAQ to:

o Organize the effort. o Force decision makers and leaders to decide on goals, craft a coherent strategy, and understand and accept the tradeoffs. o Internally sell transparency and scrupulous honesty as essential to success. o Help the legal team be a partner, instead of just saying “no”. o Simplify and accelerate communications and make the Marketing Department an ally.

We’ll be using a bit of FLOSS history to illustrate our points - Sun’s Open Source Java Initiative.

Java wasn’t always Free Software. By 2005, Sun was making a lot of money with its staunchly proprietary Java platform. Richard Stallman called it a seductive “trap”. Under pressure from FLOSS community leaders to open source Java and turn it into a compelling example of the new model, Sun listened.

Those of us on the Java team were just as surprised as the rest of the software world by the announcement. Immediately, the questions started pouring in: Which license? How to encourage and manage contributions? What happens to the brand, and to Java’s “Write Once, Run Anywhere” compatibility promise? How does Sun continue to make money with Java, when the code is out there for anyone to use without paying a fee?

Sun didn’t know the answers. And these questions were in the minds of Sun’s customers, competitors, and knowledgeable FLOSS leaders. We needed a way to:

o Answer the hard questions consistently and in one place so everyone would know. o Get the whole company on board, including management, lawyers, salespeople, engineers, and marketing personnel. o Communicate the answers successfully to diverse internal and external audiences. o Convince skeptics on both sides that this initiative would succeed in future-proofing Java’s business while keeping the platform relevant and exciting.

Thus was born the “Open Source Java FAQ”, which was inspired by an earlier FAQ done for the Debian community, and grew to 200 questions. It would prove to be a key tool in solving these problems.

Introducing Ftrace and using it for Linux realtime application

Ftrace (Function Tracer) is a very famous tracing/debugging tool. It is built directly into the Linux kernel and most of standard distributions already have various configurations of Ftrace enabled in their most recent releases.

One of the benefits that Ftrace brings to Linux is the ability to see what is happening inside the kernel with a large number of 'tracers' (function or events) .

• kernel function calling tree and timestamps
• kernel events (such as processus wakeup or switch)

As such, this makes finding problem areas or simply tracking down that strange bug more manageable. Ftrace's ability to show the events that lead up to severe problem gives a better chance of finding exactly what caused it and can help the developer a lot. API to talk with Ftrace is located in a Debugfs file system. typically mounted at /sys/kernel/debug. You can also use 'trace-cmd' utility for easier access.

After a brief history and introduction about tracing tools (SystemTap, eBPF, LTT-ng, ...) we will (briefly) talk about Ftrace internals and describe main features :

• installing it on embedded distribution such as Buildroot or Yocto (ARM platform)
• tracing kernel functions (function, function_graph)
• kernel messages (trace_printk)
• markers (trace_marker)
• events

After describing a simple use-case for a kernel driver we will focus on events and use trace-cmd on "realtime" application running on standard Linux then PREEMPT_RT (ARM).

We will compare performances of a POSIX based periodic task using SCHEDFIFO or SCHEDOTHER on both kernel and finally generate graphs with GNU-plot.

The progression of microservices in the industry resembles me the way microservices progressed at Google. First, a common container format. Then, a way to express complicated systems in terms of containers. Then, tools to deploy them and services to schedule them. Then, core networking services to support the complicated networking requirements of our highly large systems with complex dependencies. Then, observability: collecting diagnostics data not just to recognize and debug production problems, but also to provide critical signals about usage to our highly adaptive and scalable environment.

The LibreOffice' bugtracker lists hundreds of tickets regarding fonts. Besides rendering issues many tickets are related to what is bundled, how missing fonts are substituted, and how to deal with installed fonts. The talk will give an overview of the problems, shows how competitors solve it, and presents a proposal to improve LibreOffice.

Google tracks you even with location service disabled. Your smartphone can be taken over remotely via WiFi. Opening media files remains an (unpredictable risk)[https://en.wikipedia.org/wiki/Stagefright_(bug)]. Despite all the effort put into mitigation techniques we don't seem to make good progress with the privacy and security of our mobile devices.

We present our vision of Componolit, an open-source platform for trustworthy mobile devices. Based on the Genode OS framework, the component-based system will provide strict isolation between apps, services and drivers. The platform will enable users to run arbitrary unmodified Android apps without giving up control of their devices. This is realized by trustworthy policy objects implemented and formally proven in the SPARK language.

The RED Method defines three key metrics you should measure for every microservice in your architecture; inspired by the USE Method from Brendan Gregg, it gives developers a template for instrumenting their services and building dashboards in a consistent, repeatable fashion.

In this talk we will discuss patterns of application instrumentation, where and when they are applicable, and how they can be implemented with Prometheus. We’ll cover Google’s Four Golden Signals, the RED Method and the USE Method. We’ll also discuss why consistency is an important approach for reducing cognitive load. Finally we’ll talk about the limitations of these approaches and what can be done to overcome them.

The GNU Guix package manager offers some useful and exciting features and properties, but with this comes some options about how to make use of these.

This talk will explore different ways in which Guix packages can be used, and what these different ways offer in terms of distributing, reproducing, versioning and isolating packages.

I'll share things we've learned while working on improving browser front-end performance. Techniques, best practices, what to definitely avoid, etc. There won't be a deep dive into any specific tool, but examples of how we measured performance and avoided / eliminated regressions during the Quantum / Photon development cycle, and what things we learned along the way.

Toro is a x64 kernel that dedicates all system resources to the embedded user application. The result of the compilation of Toro is an image that contains both the kernel and the application. The kernel image can be booted by all majors hypervisors Hyper-V, KVM, VMWare ESXi, and emulators Qemu, VMWare WorkStation, VirtualBox. In these environments, the application runs directly inside the kernel without the need of a general purpose operating system. In this talk, I will present recent experimentation in which the scheduler of Toro is optimized to reduce the CPU usage of a VM. It has been identified three cases in which the scheduler can be optimized to reduce the impact of idle loops. To validate these techniques, I will present the impact of the improvements on a live running Toro VM on top of QEMU and Hyper-V. Open questions are welcome throughout the session to discuss the benefits and drawbacks of this approach but also take-away lessons.

To improve the historically mediocre performances of the Linux kernel regarding high-speed networking, the community has been working hard over the last years. In particular, eBPF (extended Berkeley Packet Filter) programs, when attached to XDP (eXpress Data Path) hooks at the driver level, provide a fast in-kernel programmable data plane.

Because XDP is so low-level, the only way to move packet processing further down to earn additional performances is to involve the hardware. In fact, it is possible since kernel 4.9 to offload eBPF programs directly onto a compatible NIC, thus offering acceleration while retaining the flexibility of such programs.

Building the compatible NIC, and optimising the offload process are not trivial. The objective of this talk is to present the current state of eBPF offload, the challenges that have been overcome, and the ones that lay ahead.

A demonstration of the new features in version 5 of KiCad, along with a quick state of the union, by KiCad's project leader.

This presentation will go over all the recent additions to Upipe, what's coming, how easy it is to add new modules and why it is the best multimedia framework in the universe.

Upipe is a recent multimedia framework coming from the mastermind behind the original VLC. It was designed to solve a lot of shortcomings in the existing multimedia frameworks and comes with all you need to create live low-latency professional television software.

Learn how we're creating the core infrastructure for broadcasting live television to millions of people all around the globe, 188 bytes at a time.

We'll briefly present the latest modules additions to the framework and what we're currently working on.

i3 is a tiling window manager aimed at developers for maximizing their productivity and control on their windows appearance, while maintaining maximum simplicity.

The idea behind tiling window managers is to give full control over the arrangement and placement of windows with minimal efforts, only displaying what's required and wanted.

The talk will introduce the project and its core principles, as well as a demonstration of how it works and some little hacks for customizing your setup. At the end of the talk, I hope you're eager to install and try i3!

Presentation on the DIGImend project's efforts to improve Linux support for generic graphics tablets.

Wacom graphics tablets are very well supported by Linux, thanks to the efforts of several core developers and many contributors, including Wacom engineers. However, the story is not so great for tablets from other manufacturers. Those range from the minimal 4.5" signature pads to full-blown 22" tablet monitors. Usually developed by OEMs in Taiwan, those tablets can be accompanied by very poor attempts at Linux kernel drivers, but most of the time no Linux support at all.

This talk is going to present the DIGImend project's efforts to improve support of such graphics tablets in Linux, the hardware peculiarities, software and organizational challenges, and what it takes to make one supported.

Because of their low price, generic graphics tablets are very attractive to artists just starting out, or living in developing countries. Same artists, who, for the same reason, would rather use Linux and Open-Source software, if only their graphics tablet worked with it. One of the aims of the DIGImend project is to support such artists.

The software development world has changed. With trends like continuous integration and cloud scaling of workloads, deployments come fast and furious (and frequent!). Is Java too big and slow to play in the new world? Never fear! Learn how the Eclipse OpenJ9 JVM has been approaching these challenges using SharedClasses, dynamic AOT now and some of the projects future directions.</div>

OpenJ9's SharedClasses cache is similar to OpenJDK's CDS but takes a more dynamic approach. This talk will introduce some of the feature of the Eclipse OpenJ9 JVM that help it provide high performance while making efficient use of memory. This session will explain why these tradeoffs are critical for cloud deployments

You need to write (technical) texts now and then? But you are not sure how to structure them, how to phrase your content, or how to best address your readers? This workshop shows you how to optimize texts to make them easier to understand (and translate). Get to know universal principles that can be applied to a wide variety of text types - including release notes, bug reports, error messages, or e-mails.

Samba AD is a free software implementation of Microsoft's Active Directory solution. It took more than five years to port Samba AD to MIT Kerberos and now it is a part of Fedora 27 release. However, the work does not stop here. Active Directory is a complex set of technologies and one of driving factors behind Fedora Server work is to make them easier to deploy and manage. The talk will go into details what is needed to be done to make Fedora a preferred distribution to deploy Samba AD.

DTrace for Linux

DTrace is a dynamic tracing tool that allows kernel and userspace tracing in operating systems. It was first implemented for Sun's Solaris and later adopted by other operating systems (Mac OS X, BSD). The Linux port is still ongoing.

In this talk, I would like to introduce the D language and its features. After a brief introduction the talk will focus on the architecture of the DTrace itself. Last part of the talk will be focused on the current status of the project.

DTrace is able to process data directly in kernel like eBPF. This allows us to perform some actions at the time an event has occured rather than during post processing of the records later in userspace. It allows also more precise selection of events of interest.

It is possible to use DTrace in many use cases:

- A kernel hacker may precisely monitor the Linux kernel
- A system administrator might use DTrace as an underlying technology
  for observing system behavior.
- Participation in distributed tracing of complex scenarios

I would like to show some real life examples how DTrace can be used to inspect running system or as source for external telemetric system.

There are many tracers in the Linux world today with different aproaches to achive their goals. One way to group them depends on when the data processing happens.

DTrace is a predecessor of eBPF. The difference is that eBPF alone is not easy to handle from user perspective. For that purpose a BCC project has started that provides compiler and runtime libraries based on llvm to allow end users write tracing tools in high level languages (C/Python). DTrace is based on D language (DTrace own language) and has its own compiler built-in. This does not require any high-level language skills or extra tools to start using DTrace.

Community driven and fully FOSS, Godot Engine has established itself as the main 2D and 3D game engine in the FOSS ecosystem, and one of the key players in the game development industry as a whole. Its third installment brings 18 months of hard work from over 400 contributors, and so many features that we can't possibly showcase them all during a lightning talk - still, we will give a quick overview of the engine, its strength and the most striking features that may light in you the spark of game development using FOSS tools!

The award-winning 2D and 3D FOSS game engine Godot got its bigger release so far in January 2018, and after 18 months of intensive development (10 to 20 pull requests a day!) it is ready to shine as the best game engine in the free software ecosystem, and one of the best even against proprietary engines, gathering a lot of interest from the game development industry.

Godot 3 brings state-of-the-art rendering features such as PBR shading (Physically Based Rendering), real-time global illumination, GPU particles and many more. It runs flawlessly on the Web using WebAssembly and WebGL 2.0 (even the editor itself, which is a Godot game!), and also exports to most desktop and mobile platforms (including of course Linux, *BSDs and even Haiku). On the scripting side, Mono/C# is added together with VisualScript and GDNative, an interface to use native code in Godot, paving the way to support languages such as Python, Nim, D, Rust and others. It ships with Bullet as physics engine, and a completely overhauled audio engine with advanced sound engineering effects. And many more features which can't all be listed here, but which the overenthusiastic Godot developers spread all over the FOSDEM campus will gladly tell you about at length!

This lightning talk will give a fast overview of what Godot is and the awesome features packed in its third installment. The presentation "slides" will even be a Godot game themselves, allowing to showcase game examples and special effects directly during the presentation.

This talk will present a high-level, consistent view of the properties of programming languages that are relevant to the design of language package (dependency) managers - and the communities that form around them. The talk is drawn from my experience in leading the efforts around Go's package management, and the ongoing and evolving efforts to take language package management from an incidental thing that languages "just have," up to a domain of inquiry and engineering that is about programming languages, but also independent of them (much like compilers). Writing I have already done (https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527) is considered by a lot of folks who work in this area to be foundational in this new phase; I hope to have a number of new thoughts and writing to present by the time FOSDEM 2018 comes around.

Logging events is important for every device connected to the Internet or a network. The syslog-ng application is an enhanced logging daemon, with a focus on portability and central log collection. It collects logs from many different sources, processes and filters them, and finally it stores them or routes them for further analysis. IoT developers can get started with it quickly, as its configuration language is similar to programming languages.

Logging events is important for every device connected to the Internet or a network. The syslog-ng application is an enhanced logging daemon, with a focus on portability and central log collection. It collects logs from many different sources, processes and filters them, and finally it stores them or routes them for further analysis. IoT developers can get started with it quickly, as its configuration language is similar to programming languages.

From this session you will learn how to use logging for collecting usage statistics, monitoring, security, or debugging running applications, using examples from syslog-ng. We will discuss some interesting use cases from a wide range IoT devices: consumer devices, like the Amazon Kindle or the BMW i3 electric car IT appliances, like NAS and network devices industrial uses, like National Instruments devices

In addition to acting as a logging agent, syslog-ng can be your logserver and collect data from IoT devices. The syslog-ng application can parse incoming data for interesting information, anonymize it if required by compliance, and route results to the proper destination. Other than saving logs locally, you have many possibilities, including visualizing logs using Graphite, creating alerts using Riemann, analyzing them in Kibana, or saving them to Hadoop HDFS for long term storage.

This talk will focus on the High Efficiency Image Format. HEIF is an image format based on HEVC compression technology, and standardized by MPEG. The GPAC team is a contributor and provides tools to support it.

This presentation will introduce gRPC, gRPC-Web and GopherJS to attendees. At the end of the presentation, they will know how to create a GopherJS frontend and leverage GopherJS gRPC-Web bindings for the communications with a generic Go gRPC backend.

I'm the author of the GopherJS gRPC-Web bindings. The library is based on the TypeScript gRPC-Web library by Improbable. It allows the user to define the frontend-backend interface as a proto3 protobuf file and generate a Go-gRPC-client-like interface for the GopherJS frontend to consume. In addition, it allows the user to write GopherJS frontends for generic gRPC servers, with the use of a proxy developed by Improbable. For more information about gRPC-Web see Improbable's blog post.

My library further extends the capabilities of the Improbable library by adding client side and bidirectional streaming over a websockets with a custom Go proxy library.

I have developed a demo for the library, available on https://grpcweb.jbrandhorst.com.

The presentation will start with a quick introduction to Protobuf, gRPC and gRPC-Web, then introduce GopherJS and my GopherJS gRPC-Web bindings and walk through development of a small web app using GopherJS, the GopherJS gRPC-Web bindings and a generic Go gRPC backend server. I have previously delivered a lightning talk to the London Go User Group on the topic of this library, recording available. For this talk I will be able to talk more about the implementation details and walk through getting started with developing a GopherJS web app. I will wrap up with a summary of what we've discussed.

Mitchell Baker, executive chairwoman of the Mozilla Foundation and Mozilla Corporation, will share the organization's vision on the future of the internet.

Deep Packet Inspection (DPI) and other specialized packet processing workloads are often run in user space due to their complexity and/or specialization. With the increase of Ethernet speeds from 40, 100 to 200 Gbits/s, the need for high-speed raw Ethernet frame delivery to Linux user-space is ever increasing. In this talk, we present AFXDP (formerly known as AFPACKET V4) designed to scale to these high networking speeds through the use of true zero-copy, lock-less data structures, elimination of syscalls and other techniques, while still abiding to the isolation and security rules of Linux. AF_XDP is currently an RFC on the Linux netdev mailing list with the goal to get it accepted upstream.

In our evaluation, AFXDP provides a performance increase of up to 40x for some microbenchmarks and 20x for tcpdump compared to previous AFPACKET (raw socket) versions in Linux. To illustrate the approach, we have implemented support for Intel I40E NICs and veth, but it should hopefully be easy to port to other NICs and virtual devices as well. AFXDP is designed as an extension to the existing XDP support in Linux so that XDP enabled devices will be able to use this. We also show how SW networking libraries and SDKs such as DPDK can benefit from AFXDP to achieve increased robustness, ease-of-use and HW independence.

Name: Magnus Karlsson, Intel, Stockholm, Sweden

  Björn Töpel, Intel, Stockholm, Sweden

Bio Magnus Karlsson:

Magnus Karlsson has worked with low-level SW and microprocessor design for most of his life. Started in academia as a post-doc, but for the past 11 years he has been working "in the real world". Currently, his main interests lie in Linux networking, telecom systems and hypervisors. He is an avid cook, skier and runner, and dreams of becoming a wine grower or beer brewer at some point in his life.

Bio Björn Töpel:

Björn Töpel has dabbled in all kinds of networking stacks, ranging from Skype's peer-to-peer stack, high-frequency trading platforms all the way down to Ethernet device drivers. For the moment, most of his time is spent in the Linux kernel. He's a coffee addict, avid runner and wannabe librarian.

We have recreated one of the first modern computers using a low cost FPGA board, Arduinos, 3D printing and simple discrete electronics. Aimed at schools and hobbyists, this open source project allows a new generation to experience the operation of a computer from 1948.

This talk will tell the story of the project, culminating in the three day extravaganza that was ChipHack 2017. I will be demonstrating all the components of the system: the delay line, the 3D printed peripherals and the processor core on FPGA. At the end of this talk, I hope you will understand more about this historic computer and be inspired to build your own EDSAC.

Chip Hack was run as part of the Wuthering Bytes Technology Festival 2017. To celebrate the 60th anniversary of the British computer society, EDSAC was recreated on the myStorm FPGA boards. The Verilog implementation was written by Hatim Kanchwala, a Google Summer of Code student from India. The key EDSAC peripherals were reimagined and interfaced with the FPGA boards.

Sir Prof Maurice Wilkes designed EDSAC and built it with the University of Cambridge. Instead of trying to make the computer the fastest or smallest, he wanted EDSAC to be useable so that everyone at the University could have access to a computer for their research. EDSAC stands for electronic delay storage automatic calculator and was based on EDVAC, a binary stored-program computer.

Punched tape was used to read in the programs. The tape was written using 5-bit wide code. In the reimagined version of EDSAC punched tape was read by reflecting light off of the paper as it was fed through by a motor. The amount of light reflected corresponded to the colour of the tape therefore a hole, substituted for by a black dot, could be found. An extra line of dots down the middle worked as a clock line.

Once the program was completed successfully the output would be sent to a teleprinter, a typewriter like electro-mechanical machine. To simulate this, a thermal printer that was able to communicate with an Arduino was interfaced with myStorm Verilog EDSAC. The thermal printer was also used to print the punched tape.

When EDSAC was turned on, a series of instructions had to be read into the machine. This was error prone and took a very long time to do. To fix this problem, rows of switches were added to the front panel of the computer. This meant that the initial instructions could be boot-strapped in upon start up. Due to the price of toggle switches, the reimagined front panel used two rows of headers and connectors. The bottom row of headers was always positively charged. Each set of headers were connected to an Arduino pin. Therefore, when a header pair was connected the pin is pulled high.

The last peripheral reimagined were the delay lines. These were used as part of EDSAC logic to hold multiple words of information. A short word was 18 bits long and the long word was 36 bits long. Due to problems with the logic system, the last bit for each word was lost and so a short word is usually seen to be 17 bits long and the long word is 35 bits long. To store the word, pipes full of mercury had series of pulses send from the top to the bottom of the tubes. A logic circuit would be able to convert the signal received upon every clock pulse to binary and send it back to the top of the tube to be sent down again.

To simulate the mercury delay lines, a material that was safer and cheaper was used to fill the tubes, air. Similar to the original design, a series of pulses held by a 4 kHz carrier was sent down the tube. An Arduino was able to reassemble to series of pulses at the bottom of the tube and resend the information down the tube. Due to travel issues the tubes had to be short so only a few bits could be held in the tube at any one time.

All materials used were open source because the teaching resource created was designed to be easily used in classrooms and maker spaces. All reimagined peripherals use OpenSCAD and a RepRap 3D printer for the 3D printed components.

Overall, Chip Hack was a great success. Everyone who came learned something about Verilog and enjoyed the talks about the history behind EDSAC. It is quite difficult to get the pacing correct when designing a course for beginner and expert so a lot of people needed to spend extra time on the tutorials.

Real-time in OpenStack is a thing now. Let's explore what this actually looks like to a user, and (in brief) how it works under the hood.

Since Juno, OpenStack projects like nova have been on a steady march towards adding the features and capabilities that users with NFV and HPC workloads really need from their cloud. The latest of these nova features builds upon earlier work to finally make real-time workloads in an OpenStack cloud a reality. In this talk, we take a peek under the nova hood to see how this feature works and how it ties into earlier work in this area (hint: KVM + libvirt do most of the heavy lifting). We then demonstrate why this matters and how you can use this feature and others like it in your own applications.

Free software is proud of its diversity, choices, and resulting variety, including but not limited to configuration. In this talk we will reflect on the last 13 years of experiences based on a user survey (286 answers), code analysis of 16 projects (comprising about 50 million lines of code), and our experience with Elektra.

Elektra aims at keeping the diversity and modularity of the FLOSS ecosystem but also unifies configuration access by abstracting access to any configuration source using key/value pairs. Participating applications do not use any hard-coded configuration. Developers, maintainers, and system administrator can declaratively specify location and syntax of configuration files, how to validate configuration, and how to derive default values.

Elektra follows the trend to a more declarative no-futz system (a system where no experimental tinkering or fiddling is needed). Getting and setting a configuration value is trivial, and possible in any programming language. Elektra currently supports C++, Python, Haskell, Lua, Shell, Ruby, Puppet, and Java. It fulfils necessities long overdue, not only for configuration management, but also for better defaults. We provide many essential utilities for system administrators and developers, such validation before serializing and command-line tools with support for tab completion of configuration. But no worries: Elektra still leaves developers the fun parts, like inventing new configuration file formats.

The complexity and amount of data rises. Modern graph databases are designed to handle the complexity but still not for the amount of data. When hitting a certain size of a graph, many dedicated graph databases reach their limits in vertical or, most common, horizontal scalability. In this talk I'll provide a brief overview about current approaches and their limits towards scalability. Dealing with complex data in a complex system doesn't make things easier... but more fun finding a solution. Join me on my journey to handle billions of edges in a graph database.

The amount and complexity of data rises. The need for a database capable of dealing with those requirements is rising as well. Modern graph databases are designed to handle the complexity but what about the increasing amount of data? When hitting a certain size of a graph many dedicated graph databases reach their limits in vertical or most common horizontal scalability.

In this talk Michael will address the glitches and most important the solutions on the journey to a scalable and distributed graph database. The main topics of this talk are:

• Modern architectures in graph databases
• Scaling a graph: Bottlenecks in read and write performance
• Index free adjacency or hybrid indexes for graphs?
• Dealing with billions of edges: A graphy journey to London with ArangoDB

An overview and history of various tools and languages that allow you to use code rather than CAD software to design circuits.

For anyone used to expressing their ideas with code using a CAD tool to design electronics can be an even more frustrating exercise than normal. If you are a programmer thinking about getting into designing circuits or if you have ever thought "I could easily solve this with a for-loop" when using KiCad then this talk is for you.

We will cover the history of ideas of using code to describe electronic circuits and culminate in the presenter's own experiments in this area.

While installing and upgrading OpenBSD releases has always been a breeze, keeping a stable installation up-to-date with security and reliability patches required fetching and applying cvs(1) diffs then build a new release which had to be deployed on every maintained systems. In this talk I will introduce a new base system utility: syspatch(8). It is used to fetch, verify, install and revert OpenBSD "binary" patches.

I will also describe the patch building process which is completely privileged separated and explain how and why several parts of the build system had to be changed.

As a teaser let me give you a couple of examples.

At OpenBSD we believe that doing full builds for each patch if the proper way to go, even though it takes more time and effort. Indeed, an important thing for building patches are deterministic builds. That is especially true if the patch tarballs aren't built on the system the original release was created.

Another challenge is static binaries. These need to be re-linked every time we patch a library that's a dependency, so if you don't do a full build all the time, you have to keep a list of these binaries and manually force re-build them which is error prone.

So, you've chosen Postgres to manage your data; next challenge is where to run it at scale? Want to avoid vendor lock-in and take advantage of the latest Postgres features and popular extensions not available in managed services from commercial vendors? Need to integrate your Postgres databases with existing monitoring and deployment tools? Interested in building your own database as a service?

In fact, you can do it with existing open-source components. Our talk is a story of how the database team at Zalando created company-wide database-as-a-service based on Postgres, Kubernetes and various open-source tools we developed on our own. We will share how we run hundreds of high-availability Postgres clusters on Kubernetes and automate routine operations using our open-source Postgres operator, providing developers easy-to-use tools to create, manage and monitor their database instances.

We are going to cover, among other things:

• Kubernertes Postgres operator
• Postgres HA with Patroni
• Postgres web-based realtime monitoring
• Postgres pam authentication with Oauth2 tokens

and other open-source components. We will also show a live demo.

SPARK started in 1987 as a restricted subset of Ada 83, defined by its own grammar rules. The overhaul of the language and toolset starting in 2010 increased greatly the language subset, dropping in effect the need for separate grammar rules. Since then, SPARK has progressively adopted most of the Ada features, to a point where the last remaining non-SPARK significant Ada feature today is pointers. We have started work on including safe pointers in SPARK, borrowing the ideas of pointer ownership from Rust. So one can legitimately wonder what difference remains between SPARK and Ada.

In the first part of this talk, I will lay out the principles that have guided us through the inclusion of language features in SPARK since 2010. I will describe in particular the trade-offs that we considered for support of important features like recursion, types with non-static constraints, generics, object orientation, concurrency. I will give a preview of the support envisioned for pointers in SPARK. So that the distinction between Ada and SPARK appears clearly: it's not about quantity, it's about safety and security.

In the second part of this talk, I will give a tour of FOSS projects which are using SPARK today: Aida, Certyflie, Muen, PolyORB-HI, Pulsar, StratoX, Tokeneer. For each one, I will describe at which level of assurance SPARK is used, with how much efforts and for which benefits. Then I will focus on the largest one, Muen, an x86/64 separation kernel for high assurance. Finally, we will look at the resources which are available to the community for FOSS development in SPARK.

As distributed data parallel systems, like Spark, are used for more mission-critical tasks, it is important to have effective tools for testing and validation. This talk explores the general considerations and challenges of testing systems like Spark through spark-testing-base and other related libraries.

With over 40% of folks automatically deploying the results of their Spark jobs to production, testing is especially important. Many of the tools for working with big data systems (like notebooks) are great for exploratory work, and can give a false sense of security (as well as additional excuses not to test). This talk explores why testing these systems are hard, special considerations for simulating "bad" partioning, figuring out when your stream tests are stopped, and solutions to these challenges.

Rust is a modern systems programming language with compiler-enforced memory-safety guarantees, safe concurrency and a powerful type system. L4Re offers safety features on the operating system level through isolation and virtualisation. Both together can form a unique combination for reliable and secure services. In this talk, I will present my port of Rust to L4Re and discuss some of the challenges of integrating the compiler Rustc into a different build system. I will also discuss future work on how to apply Rust's strong type system to L4Re IPC.

This talk will be a short refresher on the various functionality available in LibreOffice for (textual) URI processing. For historical reasons, that functionality is more arcane and error-prone than it needs to be. We will be looking at the typical pitfalls and fixes.

As the industry moves towards more cloud based and containerised solutions such as Kubernetes, monitoring tools have to keep up. These new environments are far more dynamic than the hand-maintained machines of old, requiring more sophisticated and scalable approaches. This talk will look at how Prometheus has evolved over the past 5 years to be better able to cope with these challenges, including the 2.0 release and practices that we encourage in a cloud native world.

This talk will cover the dynamic nature of cloud-based services, and how approaches that worked when everything had a dedicated machine no longer work out both technically and in terms of human operational effort. This includes the dynamic nature of cloud-based environments where there can be high churn due to releases potentially several times an hour, heterogeneous performance of replicas and complex micro-service dependency graphs. There will be a quick overview of the history of the TSDB of Prometheus, giving context to the new storage engine in the 2.0 release and how it helps with the above technical problems. Following that will be a look at service discovery to find what to monitor in dynamic environments, the aggregation abilities of PromQL and how these can be combined to perform symptom rather than cause based alerting using techniques such as the RED method.

The OpenJDK JVM eats class bytecode and spits out Java heap objects and machine code as part of normal execution. However, the JVM manages more data than just bytecode, Java objects JITted code. In order to manage heap memory and to ensure correct execution, the JVM and JITted code need to retain and, occasionally, interrogate details of the loaded class base. Bytecode is not a very 'efficient' representation for this purpose, nor does it include details of runtime-derived info like class and method implementation dependencies, compile history and JITted code status, or execution profiles.

So, the JVM throws away most bytecode after parsing, in its place constructing and maintaining its own 'efficient' in-memory (C++) data structures which model both the loaded class and method base and runtime-derived state. This is what is known as Class Metadata. Class Metadata is a significant component of the Native Memory storage allocated and managed by the JVM, alongside JIT Compiler Metadata, GC Metadata, Thread Metadata, etc. For small applications that don't create a large number of Java objects Metadata can constitute a large portion of a Java application's resident memory set.

This talk will begin by describing how to use the jcmd tool to measure summary JVM Native Memory storage costs, including overall Class Metadata costs. It will also show how to use jcmd to obtain a detailed breakdown of the latter costs, splitting the overheads along two axes: firstly, by class; and secondly, dividing per-class costs into separate sub-costs associated with different component subsets of the class model: classes per se, constant pools, methods and annotations.

I will go on to explain how Class Metadata is carved out of the memory regions managed by the JVM's Native Memory allocation routines and detail the memory layout of the various C++ types which define the elements of the Class Metadata model, thereby clarifying some of the more detailed statistics available in jcmd output. Real-life use cases will be employed to explain how specific costs arise from code design choices and to suggest how alternative choices might increase or decrease Class Metadata costs.

Once a year, the students of Leuven congregate to run like hell. Teams of students compete against each other in a 24 hour relay race. ULYSSIS is a student organisation that voluntarily provides many IT services for other students, like providing the automatic lap counting system at the 24 hour run, using their own software called i++. This talk will describe how this lap counting system works and describe the dream I have of a cheap user-friendly system using free and open source software, that would enable other organisations to organise similar events.

You notice a bug (problem or opportunity for improvement) and then you put a bug (metaphorical insect) into someone's ear. Most people don't like bugs (actual insects) so have you successfully bugged (bothered) them or have you done A Good Thing? When you find yourself with access to someone who could make things better for people who don't feel comfortable speaking up, how do you use this power in a way that contributes to real improvement without eclipsing other people's input? You also want to make sure that you aren't betraying confidences or triggering backlash to yourself or others. It seems like a tricky line to walk, but with a little diplomacy and lot of benefit of the doubt you can make tangible improvements to your corner of the free software community.

You notice a bug (problem or opportunity for improvement) and then you put a bug (metaphorical insect) into someone's ear. Most people don't like bugs (actual insects) so have you successfully bugged (bothered) them or have you done A Good Thing? When you find yourself with access to someone who could make things better for people who don't feel comfortable speaking up, how do you use this power in a way that contributes to real improvement without eclipsing other people's input? You also want to make sure that you aren't betraying confidences or triggering backlash to yourself or others. It seems like a tricky line to walk, but with a little diplomacy and lot of benefit of the doubt you can make tangible improvements to your corner of the free software community.

This talk will cover specific trouble-spots like unwelcoming behavior, the "we always done it this way" disease and how to coax your esteemed project lead (read: occasional control freak) into loosening their grip -- at least a little. It's also helpful to implement some solid "nothing's on fire today" systems for maintaining low temperature group dynamics, a culture of openness and transparency around shared goals. For anyone who cares about the success of free and open source software, this work is critical in both the wider community and inside our individual projects.

So, what things could we stand to fix around here and what are the best strategies for fixing them? The best way to start a bug report is with a description of the expected or desired behavior. Filing great bug reports on the people side that leave you, your project and the wider community in a better place requires just a little additional finesse. Maybe you'll let me put a bug in your ear about it?

Horizon is a from-scratch EDA package with focus on useful parts management and rule-driven design. Even though it's still work in progress and some features are missing, it's already usable for small to medium-sized projects.

This talk covers my motivation for starting a new EDA package in 2016 and the main ideas behind horizon as well as some important implementation details. I'll also go into my short- and long-term plans for the project.

Designing custom hardware, though might seem intimidating at first, can simplify many activities. It solves certain issues, but often raises many others. Paweł will present a fresh open hardware approach at providing remote access (including device flashing, debugging and power management) to embedded devices - MuxPi, successor of SD MUX board (showcased during FOSDEM 2016 and Embedded Linux Conference 2016).

This talk will introduce novices to the topic of testing on remote embedded devices and previous attempts to do so. Presentation will also introduce components of the new Tizen GNU/Linux distribution's testing laboratory (currently in the process of being published open source):

• Boruta - board farm management system,
• Weles - LAVA-compatible testing framework,
• Perun - binary image testing system.

It will focus on hardware aspects of proposed solution (MuxPi). Software stack design is discussed in detail during talk in Testing and automation devroom.

Presentation will hopefully encourage discussion on this topic or inspire attendees to try this open hardware design out in their own setups and share feedback on what can be further improved.

This talk covers my experiences designing, building and testing a open-source distributed metrics store in Go.

I'll explain:

• the system architecture and the trade-offs involved in distributed systems
• how the design evolved
• how Go is well-suited to high throughput distributed systems
• useful libraries for building such systems in Go
• using pprof to identify performance bottlenecks
• how data structures affect garbage collection in high-throughput systems
• testing strategies and failure injection

Active Directory is Microsoft's implementation of the LDAP, DNS and Kerberos protocols. It is highly popular in corporate environments. Samba as an SMB server needs to integrate into AD to participate in the Active Directory Authentication and Authorization mechanisms. This talk will give an overview of the aspects of Active Directory that Samba utilizes and gives an introduction into winbind, the main component of Samba responsible for AD integration.

Unbinding Linux kernel drivers to allow userland IO through VFIO has a number of disadvantages such as another large touchy code base to deal with the hardware, loss of standard Linux tools (ifconfig, ethtool, tcpdump, SNMPd...) and impossibility to accelerate container networking. Mediated device introduced in Linux kernel 4.10 for GPUs and provisions for additional devices hold the promise of collaboration between kernel drivers and userland application in need of direct datapath steering. Packet frameworks such as OpenDataPlane, DPDK, VPP and Netmap may benefit from leveraging mediated devices. This sessions intends to discuss the practicalities and security aspects of such an approach and how ODP and DPDK communities may collaborate on userland IO.

Topics covered: - slides: brief review of IOMMU, IOMMU groups and default group, DMA API and VFIO - slides: An overview of the proposed approach and challenges will be presented in the form of slides. - demo: crypto IO from userland and selected code walk through (generic device access) - demo: network IO from userland and selected code walk through (net_device specific extensions)

Low-Latency video over HTTP using Matroska (or all the features of Matroska you never heard about)

I'd like to show a demo of very latency streaming using Matroska for an adaptive streaming use case and compare with existing solutions like framgemted MP4 or MPEG-TS.

Large websites and webapplications commonly provide pages that require loading of Megabytes (sometimes tens of Megabytes) of JavaScript code. That's bad both for the network and for the loading speed of the page. While source code minifiers can help, they make the code harder to read and debug, and sometimes slower to load. The JavaScript Binary AST is an ongoing work to extend the JavaScript Virtual Machines with a novel compression format that should make the code both smaller and faster to parse, without making it hard to read and debug.

We'll present the JavaScript Binary AST, as well as the tradeoffs we need to make between parsing speed and file size to guarantee safety and make it compatible with future versions of JavaScript.

since 1998 I've developed an alarm system based on the velleman K8000 kit. I've first build it with Linux (slackware), in 2010 I've moved to OpenBSD. I'll describe why OpenBSD is better matching my needs than Linux.

• I'll present the need: IR captors, integration with SMS, web interface
• what were the problem with linux
• how I've setup OpenBSD with a read only file system
• Why OpenBSD is perfectly matching those needs
• future plans

Some elements are on my blog: http://vincentdelft.be/post/post_20160710

Disaster Recovery is a commonly ignored topic, only considered when something serious happen. Then, usually, is too late to react efficiently. The consequences? generally money loss and reputation, sometimes is also the beginning of the end for a company.

This short session will show you, how easy is to use ReaR and DRLM, two open source projects that, together, provide a great and flexible solution for Disaster Recovery, system migrations and OS deployments.

The whole session is a live demo, showing how easy is to:

• Install ReaR and all of it's requirements on a system from DRLM.
• Take a DR backup of that system using DRLM.
• Break the system.
• Recover from the disaster using DRLM.

All this in just few minutes!

During the session, conducted by Didac Oliveira, co-founder and maintainer of DRLM project, the attendees will see how easy is to have an open source DR solution for their GNU/Linux systems.

Questions and doubts will be answered during the session and/or at the end of it.

Note that this replaces "Integration of Bikeshare Information into an Open-source Transportation App Google Summer of Code 2017" by Rodrigo Carvalho who is no longer able to attend the event.

Some issues with the handling of DWARF locations, particularly DWARF pieces, will be outlined. Some of GDB's bugs in this area, both fixed and open ones, will be discussed. The talk mainly addresses developers of DWARF consumers such as GDB.

Please note that this talk replaces one entitled "Introduction to kmemleak" that was due to have been given by Thierry Escande, who has sent his apologies but is now unable to attend.

• Outline / goals:

  • explain subtleties with DWARF pieces;

  • outline GDB's DWARF piece handling issues, both fixed and open;

  • touch on some other DWARF location issues;

  • discuss thoughts on how to fix the remaining GDB issues.

The Open Office Editors have a long history and mighty tools in their Draw/Impress applications. Due to the long development history, and the always changing UI of software, some of these mighty tools/helpers are pretty hidden nowadays. The Presentation gives an introduction over very useful Tools/Helpers in the current LibreOffice and how to use them to your advantage. There will be a short, abstract overview, but the main part will be demonstrating/presenting these tools in direct usage. This presentation is an advanced version of the original presentation held at the LibreOffice conference 2016 in Brno. Due to the huge echo I got from the first presentation, I decided to refine it and offer it at FOSDEM this year.

In a world where a new single board computer (SBC) comes out every month it has become impossible to maintain all the proprietary methods that are used with the boards. A movement towards a unified windowing method and unified decoding methods has started. For Kodi version 18 a Direct Rendering Manager / Kernel Mode Setting (DRM/KMS) windowing method has been implemented. This allows any device that has a Linux kernel DRM driver to run kodi. The next step is video decoding, where each SBC has it's own specific decoder and software to run it. The Linux kernel implements a Video4Linux2 (V4L2) subsystem where drivers can register a decoder to be used under a common API. Kodi needs to be able to use a zero-copy path in order to display these decoded frames on the screen. For this to happen we need to use DRM-PRIME buffer sharing and specific EGL extensions to present the frames. All this together will allow Kodi 18 to run on a vast variety of SBCs that have DRM driver and a V4L2 driver available.

In order for Kodi to present decoded frames along with the GUI multiple hardware planes are needed. To use multiple planes we will make use of the DRM subsystem. Atomic DRM allows control over each page flip and what is presented by each plane within one atomic commit. In Kodi this allows showing the Kodi GUI in the overlay plane and the decoded video frames in the primary plane. The decoded video frames exit the decoder in a semi-planar YUV format called NV12 (other formats may be possible as well). These NV12 frames can be presented directly in the primary plane and the DRM subsystem handles the scaling and rotation.

Presenting directly to a DRM plane has some downsides that need to be addressed. Depending on the DRM driver things like scaling and deinterlacing may not be supported. In these cases a separate rendering method has to be used. This other rendering method is entirely done in OpenGLES using the EGL extension EGL_EXT_image_dma_buf_import. This method allows directly importing the NV12 video frame into OpenGLES and manipulation can be done from there via GLSL shaders. Kodi already implements shaders that do the YUV to RGB conversion needed to output the image to the display. These shaders also implement scaling via various methods (lanczos, spline36, etc) and deinterlacing via bobbing.

All this together will allow SBCs such as NXP i.MX6, Allwinner H3, Rockchip 3288 and 3328, Qualcomm Dragonboard 410c, and many more to work with Kodi without implementing any new methods. This work is underway is largely merged into Kodi master already.

Hyphe, a web crawler for social scientists developed by the SciencesPo médialab, introduced the novel concept of web entities to provide a flexible and evolutive way of grouping web pages in situations where the notion of website is not relevant enough (either too large, for instance with Twitter accounts, newspaper articles or Wikipedia pages, or too constrained to group together multiple domains or TLDs...). This comes with technical challenges since indexing a graph of linked web entities as a dynamic layer based on a large number of URLs is not as straightforward as it may seem.

We aim at providing the graph community with some feedback about the design of an on-file index - part Graph, part Trie - named the "Traph", to solve this peculiar use-case. Additionally we propose to retrace the path we followed, from an old Lucene index, to our experiments with Neo4j, and lastly to our conclusion that we needed to develop our own data structure in order to be able to scale up.

Speakers

• Paul Girard
• Mathieu Jacomy
• Benjamin Ooghe-Tabanou
• Guillaume Plique

OpenStack deployments are increasingly embracing distributed file storage solutions for virtual servers to provide fault-tolerance, mobility, and shared state between servers. The Ceph distributed file system (CephFS) has taken aleading role in providing this as a cache-coherent, horizontally scalable, and POSIX-compatible file store for OpenStack operators, leveraging Ceph's dominance and flexibility in OpenStack deployments where it already provides object and block storage solutions.

The OpenStack Shared File Systems service, Manila, provides a modular framework for securely exporting file shares to tenants in the cloud. In this session we will describe how Manila has been extended to support export of shares backed by CephFS via the NFS protocol to tenant VMs. We’ll discuss reasons for using NFS instead of or in addition to doing native CephFS exports and cover current and planned approaches to such issues as multi-tenancy, performance, and scale out of services.

This talk will be of immediate practical interest to cloud operators who have or are planning use Ceph clusters for object and block storage and want to use the same cluster for shared file services as well as to those more generally interested in Manila, distributed file systems, or Ceph evolution.

OpenStack deployments are increasingly embracing distributed file storage solutions for virtual servers to provide fault-tolerance, mobility, and shared state between servers. The Ceph distributed file system (CephFS) has taken a leading role in providing this as a cache-coherent, horizontally scalable, and POSIX-compatible file store for OpenStack operators, leveraging Ceph's dominance and flexibility in OpenStack deployments where it already provides object and block storage solutions.

The OpenStack Shared File Systems service, Manila, provides a modular framework for securely exporting file shares to tenants in the cloud. In this session we will describe how Manila has been extended to support export of shares backed by CephFS via the NFS protocol to tenant VMs. We’ll discuss reasons for using NFS instead of or in addition to doing native CephFS exports and cover current and planned approaches to such issues as multi-tenancy, performance, and scale out of services.

This talk will be of immediate practical interest to cloud operators who have or are planning use Ceph clusters for object and block storage and want to use the same cluster for shared file services as well as to those more generally interested in Manila, distributed file systems, or Ceph evolution.

Patrick Donnelly

Patrick Donnelly is a software engineer at Red Hat, Inc. working as the project team lead for the Ceph distributed file system. In 2016 he completed his Ph.D. in computer science at the University of Notre Dame with a dissertation on the topic of file transfer management in active storage cluster file systems. He has given talks at conferences including IEEE CCGrid, IEEE CloudCom, IEEE/ACM Supercomputing, and LinuxCon Vault.

Ramana Raja

Ramana Raja is an upstream contributor currently working on integrating CephFS with OpenStack Manila. He's been involved in the Manila project since the Juno release. Besides the OpenStack project, he's contributed to other popular open source projects such as Ceph and Gluster.

Victoria Martinez de la Cruz

Software engineer at Red Hat, FOSS passionate and tech in general enthusiast. Former Zaqar and Trove core reviewer. Currently working on Manila. OpenStack Outreachy and Google Summer of Code coordinator. Eager to learn about new technologies, to contribute to different open-source projects and to get new people involved with open-source philosophy.

Tom Barron

Tom leads the Red Hat OpenStack Platform Manila development team and is a leader and active core core team member in the upstream Manila development community. He started working on OpenStack Cinder during the Juno release and maintains a keen interest in cross-project initiatives. Today he focuses on hardening Manila as an enterprise quality orchestration and abstraction layer regardless of the storage back ends used, and on helping enable use of CephFS to provide a 100% open source distributed file system solution with Manila for open source clouds.

Graphite meets Cassandra to Scale Monitoring at Criteo

This talks is about the BigGraphite project: https://github.com/criteo/biggraphite

People love or hate Graphite (https://graphiteapp.org/, https://github.com/graphite-project), and whatever might be your take on it, it's huge part of the open source monitoring ecosystem. Graphite store data in it's own database, called whisper. But managing whisper at scale can become a challenge. BigGraphite original goals where to reduce the human cost of maintaining Graphite at scale by allowing SRE teams to easilly add and remove machines.

This talk will explain how we did it, how we use Graphite at Criteo, and our future plans for BigGraphite.

See the deck of slides to know more: https://docs.google.com/presentation/d/17opE2U2aIe1TFYJgr0Z8Dd2fJhy2x0YbReCVeCz6uhA/edit?usp=sharing

The talk will be shortened to fit in 25min (+5 min questions).

Container technologies such as Docker are rapidly becoming the de-facto way to deploy cloud applications, and Java is committed to being a good container citizen. This talk will cover some of the new the tools and techniques for reducing container size (jlink, Alpine/musl support), for improving startup time and sharing of data between JVMs (AppCDS and ahead-of-time compilation), and the recent work that has gone into interacting with container resource limitations.

In this talk we will look at how XWiki SAS has been able over 14 years to build XWiki as Open Source and also launch recently the CryptPad project while keeping an honest community open and a fair Open Source model. What has been the challenges to make this happen and what questions have been asked internally. We will also discuss what criteria are or not compatible with an Open Source project and an fair and honest community oriented process.

XWiki: a case study on managing corporate and community interests

In this talk we will look at how XWiki SAS has been able over 14 years to build XWiki as Open Source and also launch recently the CryptPad project while keeping an honest community open and a fair Open Source model. What has been the challenges to make this happen and what questions have been asked internally. We will also discuss what criteria are or not compatible with an Open Source project and an fair and honest community oriented process.

XWiki is and Open Source software created 14 years ago by Ludovic Dubost and developed under the LGPL licence. The XWiki software is used by thousands of companies to help them organize information. CryptPad, created by the XWiki team in 2016, is a realtime encrypted pad allowing to share information without exposing your content to your cloud provider.

This talk will give you a short introduction to LibrePCB, a new software for designing printed circuit boards. The goal of the LibrePCB project is to create a modern, powerful and easy-to-use EDA package for everyone. The project is still in a quite early development stage, but is already usable for creating simple PCBs.

In addition to a short live demonstration, I'd like to talk about the motivation behind LibrePCB, explain some of its concepts and what plans we have for the future.

We had a number of interesting problems threading the Calc computation core, come and see how we addressed many of them and checkout the result.

Come and hear the story of how we threaded the Calc core to get some great efficiency wins on the new deeply threaded Ryzen era. Hear about the rather complicated Calc-ulation core, and see how we used tool to profile and optimize from cachegrind, oprofile, perf and many others. Discover some of the challenges of spreadsheets, why it's perhaps not quite as simple as you might hope, see how we tried to make this maintainable and test-able.

Checkout the feeds and speeds, and help advise us on how we

can improve concurrency and scalability for your particular use-case and how you can involved contributing to Calc.

Pairwise (a.k.a. all-pairs) testing is a test case generation technique that is based on Microsoft's observation that most faults are caused by interactions of at most two factors. Pairwise-generated test suites cover all combinations of two therefore are much smaller than exhaustive ones yet still very effective in finding defects.

I have taken the pairwise approach and applied it during an entire release cycle of Red Hat Enterprise Linux. I've made an experiment where I have reduced the test matrix for 9 product variants and 4 CPU architectures to a size suitable for execution by a single person. In this talk I will explain: - what is the background of the product and how it was traditionally tested - how I've constructed my experiment - how many test cases I was able to remove from the test matrix - how the results and risk level compare to the standard exhaustive test suite!

I will also talk about bugs found and bugs missed by the two approaches.

Starviewer is a user-friendly diagnosis application. Thanks to its versatility, it is able to combine, in the same environment, the day to day diagnosis interface with a more specific research application. The platform is the result of combining research knowledge of Graphics and Imaging Laboratory technicians, from the University of Girona, with the experience of the radiologists from Institut de Diagnòstic per la Imatge, a prestigious imaging institute located in the main Catalan public hospitals. Starviewer has been in use for more than 10 years and has about 600 daily active users.

Starviewer integrates in the same environment basic and advanced image analysis techniques to assist radiologists in diagnosis. The modular design of the platform supports the integration of new funcionalities designed to diagnose any kind of pathology. Starviewer is a GPLv3+ multi-language and cross-platform application available on Windows, macOS and GNU/Linux. It supports the DICOM standard and IHE profiles.

DICOM (Digital Imaging and Communications in Medicine) is a standard for the transmission, storage and visualization of medical images and data. This standard is widely adopted by device manufacturers, storage servers and visualization software. Thus, the medical imaging ecosystem is not a walled garden.

Starviewer is developed in C++ making use of several open source libraries like Qt, VTK, ITK, DCMTK, GDCM and ThreadWeaver. It has modules for 2D and 3D visualization, and for DICOM printing. Additionally, there are several research modules focused on segmentation, registration, etc. which are not intended for daily use. Our main goal is to provide a medical image viewer focused on the image diagnosis process that is quick and efficient, and covers most of the daily needs.

RAWcooked encodes RAW audio-visual data into the Matroska container (MKV), using the video codec FFV1 for the image and audio codec FLAC for the sound. The metadata accompanying the RAW data are preserved, and sidecar files, like MD5, LUT or XML, can be added into the Matroska container as attachments. This allows to manage these audio-visual file format in an effective and transparent way (e.g. native playback by VLC), while saving typically between one and two thirds of the needed storage, and speeding up the back-up on LTO cartridges. When needed, the source is retrieved bit-by-bit.

It is easier to see what comes next for the Internet of Things (IoT) when you have eyes on the world. Computer Vision (CV) software, in particular the powerful open source OpenCV (http://opencv.org) has made big leaps in power and usability, and is ready to come into its own as a key part of an advanced IoT solution.

At the same time the Go programming language aka Golang has won over fans with clean code, high-performance, and portability. But there has not been any way to unlock the most state-of-the-art CV libraries using the most state-of-the-art programming language... until now.

Introducing GoCV (https://gocv.io) a new package for letting Go programmers create computer vision applications using OpenCV.

In this talk I will show how to use GoCV to build the next generation of computer vision applications, with live code demonstrations.

It is easier to see what comes next for the Internet of Things (IoT) when you have eyes on the world. Computer Vision (CV) software, in particular the powerful open source OpenCV (http://opencv.org) has made big leaps in power and usability, and is ready to come into its own as a key part of an advanced IoT solution.

At the same time the Go programming language aka Golang has won over fans with clean code, high-performance, and portability. But there has not been any way to unlock the most state-of-the-art CV libraries using the most state-of-the-art programming language... until now.

Introducing GoCV (https://gocv.io) a new package for letting Go programmers create computer vision applications using OpenCV.

In this talk I will show how to use GoCV to build the next generation of computer vision applications, with live code demonstrations.

Hi, soon, i will be a WAL file. I am not born yet, but everything is ready for me. I have high expectations for my life, but what will it be?

I may end up in a lonely server after a very long work, or I may finish frozen in the archives of a cold tape band. But what I really want is to be part of a replication stream, I want to travel!

Some call me "transaction log", some others go with "Redo log", PostgreSQL community has chosen WAL. But whatever you name me, come to listen to all the lifes I could have!

Percona are known as the MySQL performance experts, and with over 4,000 customers, we have a list of how to scale and ensure your application is highly available. Come learn from our playbook, and leave this talk ensuring your MySQL database is running faster and more optimised than before.

In order applications to reach an industrial production grade level, a significant effort for automation build and test is required. This lecture provides an overview of necessary architecture to automate AGL applications build using Jenkins pipeline and XDS (X(cross) Development System) in a multi targets environement.

The main purpose of this talk is to present an architecture to build and test embedded applications automatically.

• An overview of Jenkins architecture and latest features.

• Focus on Jenkins V2 and the advantages in using pipelines.

• A quick overview about X(cross) Development System tool.

• How to pipeline and XDS to build an application, test it, publish it.

The MDN team is creating a rich data set for browser compatibility information at https://github.com/mdn/browser-compat-data Learn how you help curating this data and where it could be embedded.

We will explain the value of writing your own Ethernet device drivers from scratch and how we do this in Lua for the Snabb project.

The OpenAPI specification is an emerging specification to describe RESTful web services. The Swagger suite is a collection of tools to write such API descriptions and have the code generated in more than 29 languages, including Ada. The presentation will describe how to write a REST operation with OpenAPI, generate the Ada client with Swagger Codegen and use the generated code to interact with the server. We will also describe the generated Ada server code and how to implement the server side and run a complete REST server.

Let's debabelize the way we identify and locate software packages across tools, databases and APIs with the new purl aka. package URL!

We build and release software by massively consuming and producing software packages such as NPMs, RPMs, Rubygems, etc. Each package manager, platform, type or ecosystem has its own conventions and protocols to identify, locate and provision software packages.

When you need to track and store information for various packages, it is difficult to reference these across tools and package "ecosystems" in a clear and uniform way.

The purl aka. "mostly universal" package URL is born from a grass-root initiative to provide a simple spec and libraries and solve this problem: standardize existing approaches to reliably identify and locate software packages.

A purl is based on the expressive syntax of familiar URL strings: these are easy to grok for humans and machines alike and can work consistently across programming languages, package managers, packaging conventions, tools, APIs and databases.

A purl could be useful:

• To reliably reference the same software package across inventory and scanning tools, .
• In cross-system metadata indexing, aggregation or alerting systems that collect, catalog and monitor packages information such as versions, dependencies, licensing, etc. across multiple package managers,
• When tracking known vulnerabilities of a package or its dependencies, and eventually relate the multiple incarnations of a code package across packaging systems,
• And many other kinds of analysis, such as building dependency graphs of packages, etc.

We introduce the Ouroboros prototype, a user-space system for synchronous and asynchronous inter-process communication (IPC). Ouroboros simplifies creating networked applications by providing a single abstraction that unifies IPC and networking APIs. Ouroboros provides a powerful networking subsystem that allows building secure overlay networks on top of UDP/IP and Ethernet. To increase scale and scope, overlays can be added on top of previously created overlays. Management of applications running on top of Ouroboros, such as making a server application available on a certain overlay, can be done on-the-fly and with great ease.

This lecture will explain the basic principles underlying the overall design and inner workings of Ouroboros, combining concepts from operating systems (IPC and microkernels) and networking (packet switching) to achieve a minimal, elegant yet powerful IPC and network system. The key objective of Ouroboros is, above all, simplicity.

From an administrator's perspective, the three step process to connect processes (register / bind / allocate or bind / register / allocate) greatly simplifies the way one manages server applications.

From a programmer's perspective, the library provides a very simple API (allocate/accept/deallocate, read/write) on top of a naming system that abstracts away the details how IPC is achieved, making writing distributed applications effortless. Asynchronous I/O is done by a scalable event system modeled on BSD's kqueue. The system is configured using a single call based on the well-known ioctl/fcntl calls and configurations for integrating TLS-like security are being implemented.

As it is a lot more than just a library, the Ouroboros network subsystem integrates a fully distributed packet-switched network that can be bootstrapped on top of a UDP network or on top of Ethernet if a suitable interface is found on the system (raw sockets on Linux, BPF on FreeBSD and OSX, or netmap if installed).

Finally, we will end with some future directions in research and steps that are needed to bring the Ouroboros implementation beyond its current prototype state.

Ouroboros is under active development at Ghent University - imec and written in C for POSIX-compliant operating systems. It is Free Open Source Software and available under the LGPL (library) / GPL license (network subsystem) at ouroboros.ilabt.imec.be

This presentation explains how cryptographic hardware allows the use of private keys while preventing them from being viewed or copied. It focuses primarily on the use of Yubikey cryptographic hardware, in both piv and gpg modes. It explains how to use this hardware with popular software like openssh and Postgres.

We (Elektrobit automotive) do FLOSS based production projects in various car brands for several years. We’d like to entertain some of our most delightful encounters of the third kind in the automotive world and tell why we love bringing FLOSS on the road, where some aspects of FLOSS challenge all of us, and why we have lots of fun.

fun stories trying to turn automotive industry open source, e.g.

• GENIVI - MISRA Checker auf Kernel 8-o
• Dilemma: automotive safety vs open source
  • excursion safety vs security
  • "Tyrant devices" & GPL3 vs safety
  • that's old news btw
• Cars are sold for 8 years, last 15 years. Does Linux?
  • leverage Layering, containers, kernel ABI stability, ... ?

Class Data Sharing (CDS) is a feature that was introduced in Java 5 to improve startup performance and reduce the memory footprint of the JVM by sharing the metadata of system classes between virtual machines running on the same host. During the last years, this feature has been constantly improved. In OpenJDK 10 CDS will be extended by AppCDS which additionally allows the sharing of application classes between VM instances (see JEP 310: Application Class-Data Sharing [1]).

In this talk I will briefly introduce CDS and AppCDS. After demonstrating its various use cases, I will do a short deep-dive into the implementation details and challenges. Finally I will briefly describe how Strings and Symbols can be stored in the CDS archive and shared across VM as well since OpenJDK 9.

After the talk, the audience should have a better understand of the CDS/AppCDS feature and be able to decide whether it makes sense to use it for their own applications.

[1] http://openjdk.java.net/jeps/310

How to apply various FreeBSD technologies and features in combination with ZFS to get the most out of a system, be it a Server, Laptop, Embedded, or an Appliance.

ZFS is an advanced filesystem, but that doesn't mean it is complicated or hard to understand.

After an overview of the basics of what ZFS is and how it works, we'll delve into how to integrate ZFS into a system or product. Topics to include: * Boot Environments and how to use them - new boot environment management tool and library from Google Summer of Code - case studies / use cases * Advanced Boot Configuration (zfsbootcfg/nextboot) - Boot the new system image only once - Fall back to previous version if new system image fails to stay up for 5 minutes three consecutive times * Automated Boot Recovery (Appliance style failover/failsafe) - Fall back to rescue image if system fails to boot repeatedly (required for environments like Amazon where there is no console) * GELI Encryption Support - Improvements to allow unattended booting * Appliance Upgrading with ZFS (including zpool checkpoints) - Create a checkpoint before upgrading an appliance, revert to checkpoint if upgrade is not completely successful. Checkpoints can undo things that a snapshot cannot, like renaming or destroying an entire filesystem.

Techniques discussed will be of interest to most everyone, from users and developers for laptops and servers, to appliance manufacturers, and embedded products.

After several years a new DWARF debugging standard, DWARF5, has been released that incorporates various GNU extensions that allow to better express how to map various binary constructs created by optimizing compilers back to the original source code while reducing the size of the debugging information. This results in more expressive debuginfo, but also introduces more complexity that DWARF consumers need to deal with.

We will go over the existing GNU Extensions to DWARF, how they were adopted by DWARF5, and describe how debug consumers can take advantage of them. To reduce space a lot of different strategies are being used. Separate .debug files, .gnu_debuglink, build-ids, compressed ELF sections, debug types in ELF COMDAT sections, the Dwarf Compressor DWZ .multi files, DWARF Supplementary Object Files, GNU Debug Fission, split-dwarf .dwo files, DWARF Package Files .dwp files. The basic structure of describing a program with a tree of Debug Information Entries (DIEs) with attributes per compile unit augmented with some auxiliary data structures to map to source files, describe macros used in the source and get call frame information hasn't fundementally changed between DWARF version 2 and version 5. But the hierarchy of the representation and where the bits are stored has become much more complex. It is no longer possible to just see the DWARF descriptions as a fancy symbol table which can be simply indexed through some offsets. It has also become much more expressive than that.

LibreOffice Writer was always capable of exporting your document in a portable way in the form of the PDF filter. Today in the age of tablets, smart phones and e-readers, many users read reflowable content in EPUB, which is the new PDF to some extent. LibreOffice Writer 6.0 has now basic and 6.1 will have improved EPUB export support. This work is done by integrating the libepubgen Document Liberation library and by improving both the library and LibreOffice itself along the way. Come and see how it's implemented, where are the still rough edges and how you can help.

This talk will preset a set of techniques to make your Go programs run faster.

Starting with CPU profiling, moving through memory allocation profiling, to escape analysis, we will point out some less-well-known corners of the runtime, how they impact performance, and how to mitigate this impact.

Often, the single biggest drain on performance in a Go program is the garbage collector. Each release of the Go runtime comes with a slightly faster collector, but you can make much bigger performance improvements by not creating garbage in the first place: if you can rework your code to make fewer heap allocations, then the garbage collector will run less often and have less work to do.

Examples will be drawn from real-world experience optimising the Open Source container visualisation project Weave Cortex.

JavaScript is one of the decade’s most trending languages. It ranked #1 in popularity in Stack Overflow questions and is consistently featured in the top 10 languages of the TIOBE Index. Originally intended for client-side scripting, the language is now widely used to build complex desktop applications, write server-side code and program IoT devices. The latest standards of the language are released yearly under the ECMAScript trademark and contain sophisticated features and syntactical constructs.

Static analysis is a software testing approach that is performed without compiling and executing the program itself. This allows developers to catch programming errors before building, testing and deploying the code. There is a wide range of static analysis tools: linters and code style analysers repeatedly perform checks in IDEs, while more complex analyzers, such as type checkers, run as part of the continuous integration (CI) process.

As JavaScript is a dynamic language, static analysis approaches are particularly useful: they can detect erroneous type usages that would not be revealed by building the code, but only occur during thorough testing or even worse, at production. Thanks to the popularity of the language, there are already numerous approaches for static analysis available, such as Tern, Facebook’s Flow and TAJS. However, none of these fitted all of our requirements:

• Utilise both linter-style and complex global analysis rules.
• Evaluate rules in real-time, i.e. in sub-seconds upon each “save” operation.
• Allow users to easily extend the analysis rules.

As none of the current approaches satisfied these requirements, we built our own solution that uses a property graph query engine to represent the code graphs used for analysis and graph queries to evaluate the analysis rules. Compared to other static analysis frameworks, the novelty of our solution is twofold:

• We continuously maintain code graphs based on the latest changes on the source code.
• We use the declarative openCypher language to define the static analysis and graph maintenance rules.

Using declarative queries, our tool is able to perform the complex analysis queries quickly, including:

• Detecting asynchronous method calls with missing await statements (a common issue in the callback hell).
• Detecting unreachable code, i.e. code parts that cannot be reached through the control flow.

The analysis can be easily extended by custom analysis rules defined in the openCypher language. Building the system on openCypher also allows us to use different query engines: both mature databases, such as Neo4j, and also experimental engines, such as our own ingraph engine. The latter is our research prototype that supports live query evaluation for Cypher queries, which allows near instant answers even for complex analysis rules.

In this talk, we give an overview of the steps involved in transforming the source code file to a syntax graph and converting it to a call flow graph. We demonstrate how openCypher queries can be used to capture complex analysis rules in a concise way, and how ingraph allows us to continuously evaluate these queries.

Intended audience: Developers of static analysis tools, users looking for a flexible analysis framework

Speaker biography.

Gabor Szarnyas is a researcher working on graph processing techniques. His core research areas are live graph pattern matching, benchmarking graph queries, and analyzing large-scale networks. His main research project is ingraph, an openCypher-compatible query engine supporting live query evaluation. His research team was the first to publish a formalisation that captures the semantics of a core subset of the openCypher language.

Gabor works at the Budapest University of Technology and Economics, teaching system modelling and database theory. He conducted research visits at the University of York, McGill University and the University of Waterloo. He is a member of the openCypher Implementers Group and the LDBC Social Network Benchmark task force. He received 1st prize in the ACM Student Research Competition at the MODELS 2016 conference. He is also a frequent speaker at industrial conferences (FOSDEM, GraphConnect) and meetups (openCypher meetup NYC, Budapest Neo4j meetup).

Many open source projects are backed by commercial entities and this can lead to complications between the needs of the community and those of the corporations. This can be especially tricky for fast-growing projects where there are competing voices, pull-requests, and directions — all growing exponentially.

Docker, Inc. is one such example that created the very popular open-source 'docker engine'. To help meet the needs of both commercial and open-source constituents, Docker announced in April 2017 that the open source work would happen under the banner of the Moby Project.

This talk looks at the the different needs that drive an open source project and a product-based corporation. I'll cover what the Moby Project is and how it relates to Docker's commercial products and I'll highlight some of the experiences we had during and after the transition.

See slides at: https://speakerdeck.com/amirmc/moby-project-and-docker-inc

For developers, application logs are critical to figuring out what’s going on inside the apps we create. We tail them. We search them. We analyze and graph them.In this talk I will show Graylog as an open source log management tool, providing central storage, processing, and analysis of log messages powered by Java,MongoDB and ElasticSearch

These could be the talking points:

1.GrayLog architecture

The Graylog log server is based on Java and offers a means for combining several server nodes in a cluster for high availability and scalability. Graylog uses Elasticsearch as database for the log messages as well as MongoDB for application data.

2.Searching and analyzing: Graylog Web Interface

Graylog also has a web interface for searching and viewing Graylog messages. Filters can be applied and saved into logical “streams”, allowing you to look at a slice of your data.

3.Use case:Configure graylog in java projects with maven

As a standard for log events, Graylog promotes usage of the Graylog Extended Log Format (GELF) I will show a use case configuring graylog inside java project with the GELF appender.

4.Integrating GrayLog with LogStash

In order to create a full log solution it is suitable to combine Graylog with Logstash with a little modification of Logstash and a custom Graylog Plugin.

In the topic of Electronic-Design-Automation (EDA) Design Rules are used to validate a drawing against constraints usually set by the manufacturer. In this talk I'd like to introduce a (file-)format proposal for such Design Rules focused on the usage in PCB design.

In the past the definition of Design Rules has been a mess. Most EDA software provider (e.g. Autodesk, Altium, Cadence) have their own set of Design Rules which neither match the expectations of the users nor the requirements from the PCB manufacturers. Beside that the Design Rules are often misleading as they do not allow to describe what really breaks production or not. Because of that most PCB manufacturers give too loose rules which often break production for the customers. An open and democratic format for Design Rules could solve this. We face the issue that at least three parties are involved in these rules which I believe can only be solved by an open source format. Because of this I talked to EDA software supplieres, PCB manufactures and users and asked what they are missing and expect from it. Using this feedback I'd like to introduce our proposal and ask if and if yes, how work should be further organized. Depending on the projects schedule an practical implementation in Gerbv could be presented.

VR works on the web and it takes 10 lines of pseudo HTML to start, it IS that simple.

Yet, that's not enough, you might not just want to make a web page immersive, you might want to pull 3D interactive and animated content outside of your screen.

This and more is what the new WebXR specifications is all about!

During this short lecture you will discover how simple it is to make VR or AR experiments. Yes you might need to code but you might quickly discover that this is just an excuse to learn on pretty much any topic! From programming to 3D to mathematics to spacial sound... as long as you can quickly test your result (which is very simple with the web) then each little step becomes an exciting exploration.

In this talk, I will outline how (primarily scientific) software developers have found ways to complicate the job of the people who are responsible for compiling, installing and/or packaging their software, mainly in the context of multi-user high-performance computing environments.

Next to an overview of the commonly used techniques, the motivations behind them, and the excuses that software developers can use to get away with it, I will showcase a couple of examples of software applications that have done a great job to make the life of package managers (in the broad sense) as miserable as possible.

If you too want to make package managers cry (even more than they may already do), don't miss this talk!

The talk will explain the reasons of the ongoing work to add PCI emulation support inside of Xen. This purpose of the PCI emulation layer is to allow passthrough of PCI devices from Xen to guests without involving a third entity in the system (so far this was done using QEMU). This should allow transparent PCI passthrough to guests without requiring a QEMU device model.

Over the past three years, the growing zoo of Open Source update frameworks made updating an embedded Linux system much easier. But, the availability of a robust update tool solves only one step in the complex chain from a software artifact to an updated and working system on your devices.

Starting with a modern system consisting of a recent bootloader, kernel, init system and update tool, this talk ventures beyond the basic and already solved topics of A/B redundancy, atomicity, or simple update verification.

Enrico will present strategies for creating a robust update chain from automated testing up to full rollout management and show how to solve these challenges with recent Open Source software such as barebox, RAUC, systemd, hawkBit, casync and labgrid. You will learn how to deal with more modular and complex system setups, restricted systems, error recovery, product variants, resigning for deployment, updating the bootloader itself and interaction with verified boot.

Video compression has been around for many years now yet the basic structure of a video codec remains largely similar. And although the basis remains similar compression keeps improving. How long can this be worked on and improved before its simpler to start with something radically different. What technology would still work in a hypothetical new codec? What technology would still realistically work in a hypothetical new codec? Do software complexity, hardware area, feature needs and overall possible compression always balance out when creating video codecs? This talk shall attempt to answer most of these questions.

Vector Packet Processing is a high performance data-plane running on commodity hardware. VPP is a framework for building bespoke network functions. This talk will give an introduction to VPP architecture and function and give examples of how virtual network functions can be built with VPP.

Capabilities can be found in most modern microkernel-based systems. Sometimes the capability pattern is masqueraded under a different name though. In this talk I will tell the story of how HelenOS unwittingly started with a primitive capability system embedded in its IPC, how it evolved into the present state in which capabilities are used as task-local names for an increasing amount of user-visible kernel objects and where this might lead in the future.

Introduction to "ethical purchasing groups", presentation of the GASdotto application, and a call to extend the model in other countries.

"Ethical purchasing groups" are an established reality in Italy: groups of people purchasing goods collectively, usually from local producers, to sustain local economy, pay a fair price, and obtain fresh and healthy products. GASdotto is a free and opensource web-based accounting application developed to manage their particular economic flow (quite different from an usual "e-commerce"). The purpose of this talk is to inspire more people, especially outside Italy, to explore this purchasing model and to leverage the GASdotto platform for use in other countries.

Several years ago, AMD embarked on a long-term project to produce a first-class open-source graphics stack. While there is always more work to be done, the vast majority of our Linux users are now happily using the result of this effort. I will give a short look back at some milestones and present a non-technical overview of the components of our graphics stacks as they are today, with an emphasis on the open-source side.

The talk will include an introduction to the recently open-sourced AMDVLK Vulkan driver.

Do you want to know how Smart Cards can help you improve security and work efficiently? Smart cards are among us for decades, but they are still not widely used on daily basis by most of us, even though they provide significant advantages for both security and usability and all the tools are open source in Linux. Smart cards are no longer only credit-card sized cards, but also more practical USB dongles which are frequently combined with other features such as OTP or U2F, which can take this even further. I will go through architecture of smart cards and show you how they can be used to simplify your work.

• Anatomy of Smart Card and software using it
  • project OpenSC
• Practical examples
  • Atomic operations with OpenSC tools
  • Using smart cards with high-level tools such as OpenSSH, Firefox
  • Debugging Smart Cards problems

Hairy Security

It's getting dangerous out there, it's all over the news, IT security is simply no longer something one can ignore.

In this session we'll model all the threats to a typical web application powered by a Java back-end. We’ll have fun, state the obvious, debate and debunk a few security myths, because, remember, It’s not a question of 'if' but 'when' you’ll be hacked, at the end of this session, you’ll decide for yourself if it's really time for this Java web app to go live !

It's a fun, pragmatic, very instructive talk we've been doing in the past (well received at Devoxx France for instance)

It's getting dangerous out there, it's all over the news, IT security is simply no longer something one can ignore.

In this session we'll model all the threats to a typical web application powered by a Java back-end. We’ll have fun, state the obvious, debate and debunk a few security myths:

• Yes, strong security comes at price, it requires a brain,
• No, strong security does not mean crappy user experience,
• No, there is no silver bullet, be pragmatic,
• Yes, they are many standards and frameworks (saml, oauth, jwt, 2-way-ssl ...) ** we'll showcase a few and debate when to choose what
• Yes, SELinux and the Java SecurityManager can be your friends
• Yes, Security needs to be baked into all your automation and continuous integration. Secret Management is key

Remember, It’s not a question of 'if' but 'when' you’ll be hacked, at the end of this session, you’ll decide for yourself if it's really time for this Java web app to go live !

It's a fun, pragmatic, very instructive talk we've been doing in the past (well received at Devoxx France for instance)

Come and hear how we are bringing the advanced LibreOffice desktop functionality to the Online!

LibreOffice on the desktop is very feature packed office suite. One of the complaints that power users make in Online is that it lacks many of them: they cannot add colored borders in their paragraphs, manage tracked changes/comments, correct the spelling and grammar in the document, etc. The question is how do we bring these functionalities to the cloud at your disposal in your browser tab?

We at Collabora decided to come up with a plan to just tunnel all the hard work that developers have done for the past couple of decades: come up with appropriate infrastructure to open the dialog in headless mode, paint it as a bitmap in the backend, and tunnel the image to you in the browser. And then add life to them by tunnelling your mouse/key events back which will invalidate and update the new image you see in the browser. Of course we are not sending the whole dialog image back to your browser every time - only the part that needs updating in the dialog is sent back to the browser saving us precious time and network bandwidth improving your UX.

Microservices are becoming very popular recently. But how to run automated end-to-end tests against your product when your architecture and deployment processes are complex? How to orchestrate your test environment when your product is a SaaS application but can also be installed on-premises on bare metal or deployed into the cloud on to your Kubernetes cluster?

Using containers to automatically test your application is a great use case, but sometimes running tests only against containers might not be enough.

We decided to create a click-driven, black-box integration testing framework, using Ruby, headless Chrome, Docker and Kubernetes, to test GitLab.

This talk is a story about building this integration testing framework. It is about obstacles we had to overcome, essential complexity that we had to embrace, but also about problems that we still need to solve and our hopes for the future.

The Asynchronous Decision Making techniques commonly used in open source projects enable efficient remote collaboration, in teams which have no boss, no schedule and often no cultural consistency yet produce world-changing software.

This talk describes the key elements and tools of the Asynchronous Decision Making process, based on concrete examples from the Apache Software Foundation and from federated governments, which, interestingly, work in a similar way.

We'll reflect on how Asynchronous Decision Making supports the efficiency of our projects, and how to refine it to be even more efficient.

If our Open Source projects required synchronous meetings to make decisions, everything would grind to a halt. Even remote digital meetings are very hard to setup in our environments where there's no boss, no schedule, often no common culture and varying expectations and goals.

Yet, many our projects produce world-changing software, making many decisions every week without having to interrupt people when they are "in the zone" and without wasting everybody's time with spoken rehashes of things they already know.

Our way of making decisions asynchronously obviously works. What are the key tools that enable it, and how can we make the best use of those tools while staying inclusive and keeping the fun level high and aggravation low?

In this talk we'll discuss concrete examples of Asynchronous Decision Making at various scales ranging from small projects to the Apache Software Foundation's Board of Directors and to federal governments which use similar techniques.

Although we'll focus on software projects, it's interesting to note that these techniques apply to most types of projects, and don't even require computers.

Focusing on the key elements and tools will help us get to the essence of Asynchronous Decision Making, which should help us make better use of these techniques in our projects.

Elasticsearch is a distributed, RESTful search and analytics engine built on top of Apache Lucene. After the initial release in 2010 it has become the most widely used full-text search engine, but it is not stopping there.

The revolution happened and now it is time for evolution. We dive into the following questions:

• How did leniency help the initial adoption, but why and how do we lean more on strictness today?
• How can upgrades be improved to avoid any downtime even when changing major versions?
• How can new resiliency features improve recovery scenarios and add totally new features?
• Why are types finally disappearing and how are we are trying to avoid the upgrade pain as much as possible?
• What are examples for some clever performance improvements?
• How can you shrink and (finally) split shards in a highly efficient way?

Attendees learn both about new and upcoming features as well as the motivation and engineering challenges behind them.

A look at our approach to distributing DevOps tools between many teams (and CI), using a GoLang app to launch containers.

We needed a way to reduce the overheads associated with onboarding new starters, so instead of a document giving a list of software that needed to be downloaded, e.g. Chef Development Kit, Terraform, Docker etc. etc. they could just download a single thing which gave them a ready made development environment whether they used Mac or Linux PCs.

Initially we used Vagrant for this, but that ended up not being the best tool for the job.

Then along came Docker for Mac, and we quickly realised that, by manipulating the GoLang Docker SDK, we could just run everything in containers. Because we wrote this in Go, we could also interact with other Go SDKs for products and services we look after, like AWS and Hashicorp Vault, to prepare an environment for these containers.

This worked really well! Too well, in fact, as people from across the company started asking us "can you add XYZ to this tool?". We didn't want our tool to become bloated, so we open-sourced the guts of our tool for other teams to create their own versions, with the tools they needed.

An update on the status of the AV1 codec, from the Alliance for Open Media.

Every day we imagine some new apps we'd love to have: having an application to allow people to submit talks, to register new holiday requests, expense reports, simply get data from one site and combine it with data from another site and display that, etc. This is the long tail of application.

However in most cases we just drop the idea and continue with our life because we know it would take days or weeks to be able to develop that quickly before you could reap the benefits.

What if there was a way to have these apps developed and working in just a few minutes!

We'll demonstrate how a next generation wiki platform allows to do just that by using the XWiki open source project as an example.

A presentation on the design of the TERES Do-It_Yourself laptop, fully designed with KiCad.

Gnoga is an all-Ada library that uses the features of modern web browsers as a portable GUI. The program may run on the same computer as the browser, or on a server over the internet. Participants will be introduced to using Gnoga to create such programs.

A singleton version of the Random_Int demo program will be used to demonstrate the use of Gnoga as the GUI for a program running on the same computer as the browser. Random_Int is a very simple program that generates (pseudo)random integers in a user-specified range.

The Chattanooga demo is a text-chat server program allowing people to chat on line. It demonstrates the use of Gnoga to create web applications. A secure version of Chattanooga can sometimes be accessed at https://chat.gnoga.com/. (The certificate for this site has expired, but can still be used to ensure encrypted communication with the site.)

After installing Gnoga, the demos are available in the demo directory.

More information about Gnoga may be found at gnoga.com, especially the Tools page.

Virtio is a common framework for IO virtualization in hypervisors. It is part of DPDK accelerated Open vSwitch and allows for hardware abstracted VNFs. The virtio OASIS standard is going into the next round and the focus will be on performance improvements. We aim to make it work better on the underlying hardware but also allow for hardware implementations of virtio. This talk will give an update on the current developments and the progress made towards version 1.1. We will look into some of the new features, some benchmarking results and how these help with improving performance.

Panel discussion with some of the speakers from the Package Management Devroom throughout the day, discussion the future of package management.

The human voice is becoming an increasingly important way of interacting with devices, but current state of the art solutions are proprietary and strive for user lock-in. Mozilla’s DeepSpeech and Common Voice projects are there to change this. In contrast to classic STT approaches, DeepSpeech features a modern end-to-end deep learning solution. Based on Baidu's Deep Speech research paper, it trains a model by machine learning techniques. This model directly translates raw audio data into text - without any domain specific code in between. To train systems like DeepSpeech, an extremely large amount of voice data is required. Most of the data used by large companies isn’t available to the majority of people. That's why Mozilla launched Common Voice, a project to help make voice recognition open to everyone.

Introduction (10 min) Talk: - A short history of automatic speech recognition (ASR) - What is the motivation behind project DeepSpeech? - How does DeepSpeech work? - How good is DeepSpeech compared to other solutions?

Using DeepSpeech (10 min) Demo: - How to voice-enable a project using DeepSpech - How to translate audio data into text - Looking into the demo code

About data (10 min) Talk: - What kind of data is required to train a model? - Which corpora are we currently using to train our models? - Common Voice: What is it and how to contribute? - Unboxing first version of Common Voice corpus Demo: - How to import (corpus) data - How to create a simple corpus from own samples - How to augment samples with noise

Training a DeepSpeech model (10 min) Talk: - How does training work? - What are train, dev and test data-sets used for? - What are the required software components? - What are the hardware requirements? Demo: - How to train a simple model

Roadmap (5 min) Talk: - What's our roadmap for 2018+?

Q&A (15 min)

The RISC-V open standard ISA has been gaining traction in both academic and commercial circles over the last year, during which we've gotten our ports of binutils, GCC, and Linux merged upstream. Additionally, SiFive has announced a Linux-capable, 64-bit, quad core development board which will be available in Q1 2018. This talk discusses the history of the ISA, SiFive's open source RTL implementations of RISC-V, the state of RISC-V software, and our plans for the upcoming year.

The RISC-V instruction set architecture is an open standard originally designed for computer architecture research that, over the past few years, has been gaining widespread popularity in industry: for example, the RISC-V Foundation, which governs the standard, now claims over 100 members. SiFive recently announced the U54 processor IP, a 64-bit, quad core, Linux-capable processor. The Freedom U500 is based on Rocket Chip, an open source processor generator written in Chisel, a HDL implemented as a Scala embedded DSL.

This talk will discuss the RISC-V ISA, and the Rocket Chip processor generator. As the author is a maintainer of the RISC-V ports of binutils, GCC, Linux, and glibc, the main focus of this talk will be on the state of the RISC-V software ecosystem. If everything goes well, the first version of glibc that contains RISC-V support will release right at the start of FOSDEM and I'll be able to announce that the core software is upstream. We have a handful of distribution partners (Debian, Fedora, and OpenEmbedded) actively working on distributions based on our pre-release ports right now, so with any luck we'll also be able to announce early distro support :).

This talk will be followed by a BOF for open discussions about RISC-V ecosystem in room J1.106

We're gonna look at multi-tasking on small Cortex-M class MCUs like the ARM Cortex-M0.

After a brief general overview of the Cortex-M0 programming model, exception handling and other basics required, we'll start our deep-dive into one specific implementation in the Chromium-EC firmware. We'll look at startup code, how tasks are implemented, how to deal with priorities and peripheral interrupts.

The Chromium-EC firmware is a little (RT)OS that runs (mostly) on ARM cores of the Cortex-M class (M0/M3/M4), and powers Google's Chromebooks as well as other devices (Project Sulfur SDR). It's permissive license makes it attractive for (ab)use in other projects, since Kernel and U-Boot integration are already existing.

I will give an update on two topics involving shaders in radeonsi, the OpenGL driver for modern Radeon GPUs: the dynamic linking of shader parts, and the transition to the NIR intermediate representation.

Managing shader compilation in an OpenGL driver is challenging, because the final shader binary may depend not only on the shader source, but also on other state in the OpenGL pipeline such as framebuffer state, blending, and vertex array. When a shader is used in a new pipeline configuration, the driver may have to recompile it. This could cause noticeable stalls in some games. While on-disk shader caches can alleviate the problem somewhat, they cannot cover all cases. The approach taken by radeonsi is to split shaders into multiple parts, such as a prolog, a main part, and an epilog. In many cases, the effects of changing OpenGL states can be captured by only recompiling the prolog and epilog, which is sufficiently faster to virtually eliminate stalls.

The .text segments of these shader parts, which the driver originally gets in ELF format from the LLVM backend, are simply pasted together. This means that we cannot currently use most of the features of ELF which are taken for granted in the CPU world. Most interesting to us would be: putting large constant data into a .rodata segment, and representing LDS memory (a fast on-chip memory) as a proper ELF data segment. I will present a plan to introduce a proper ELF-based dynamic linking step into the driver to enable these features.

I also plan to present a brief update on the transition from TGSI to NIR as intermediate representation.

A short overview of what Haiku is, history of how this LibreOffice port came to be, challenges involved and what is its current status.

Up to now many medical record softwares were not mach more than narrative reports of what did appen at some time in the past in some specific context. Student can find much static knowledge on internet, but have to learn a “medical methodology” about how to use this large amount of knowledge.

Evolution to a “task oriented model”, to help to solve patients health problems. Visual support of "Natural Intelligence". Focus on the relations between medical concepts. Intended for the training of students. Mind synchronisation between the members of care teams across Internet

Rust presents new challenges for the debugging ecosystem. This talk will cover some debugging peculiarities of Rust and how we plan to solve them.

Rust is a new systems programming language from Mozilla. Debugging Rust requires new capabilities from LLVM, from debuggers, and even DWARF. This talk will cover some of the difficulties presented by Rust, and will describe ongoing work to fix these problems in DWARF, LLVM, lldb, and gdb.

FreeBSD has some knobs to set in order to build the base system or to avoid building some parts of the system. This way the build process could be optimized to avoid wasting time.

With this procedure, the user has an easier way of configuring how to build the target system

The first implementation allows the user to set, unset and check the dependencies of the option that can be set to build the base system. Lots of users uses this kind of options to speed up the process of building the base system but there are some dependencies that might not be taken into consideration and the user could realize of this changes when the build process is finished, wasting a lot of building time.

More than a lecture about this approach, this event is meant to be a demonstration of "how can it be done".

UEFI is a firmware specification created by Intel with portability in mind. The UEFI way of doing that was to provide special UEFI byte code (EBC). Unfortunately nobody really cared so compiler, firmware support and providers of EBC option roms ceased and basically every UEFI option rom today contains native x86(_64) machine code.

If you now want to plug a PCIe card into your shiny ARM server, that means even though firmware would be compatible it still can't execute the option rom. Until you add QEMU to the mix.

Join me in exploring the depth of UEFI binary interfaces, marshalling between different architecture's function call ABIs on the fly and learn how to integrate all of this into a working firmware, running on real hardware, driving a real PCIe adapter.

UEFI is a firmware specification created by Intel with portability in mind. The UEFI way of doing that was to provide special UEFI byte code (EBC). Unfortunately nobody really cared so compiler, firmware support and providers of EBC option roms ceased and basically every UEFI option rom today contains native x86(_64) machine code.

If you now want to plug a PCIe card into your shiny ARM server, that means even though firmware would be compatible it still can't execute the option rom. Until you add QEMU to the mix.

Join me in exploring the depth of UEFI binary interfaces, marshalling between different architecture's function call ABIs on the fly and learn how to integrate all of this into a working firmware, running on real hardware, driving a real PCIe adapter.

The JVM contains many interesting features that are frequently overlooked, not exposed through the Java standard library, or typically only accessible from native code. In this talk we will walk through a few of these features, and how they can be used from plain old java code. For example we will see how to access local variables from calling methods, as well as powerful ways to monitor what the JVM does when executing our code.

Free Java allows us access to these features, as well as the ability to contribute towards improving their implementation and make them publicly available to other users. Together we can influence the direction of Java and help get more powerful features into the standard JDK.

SSSD is known in the OSS world as a client towards different LDAP-like databases. However, recently, we have started taking SSSD beyond its bread and butter LDAP client role to provide services that are usable in a broader context, as an application gateway or to a local machine. As a result, you might soon see SSSD enabled and running in your favourite distribution by default or quietly running on the background of another service.

In the talk I will demonstrate what enhancements we already did in SSSD, such as how to use SSSD as a gateway between an application and a user database or why should you let SSSD manage your Kerberos credential caches .

I'll also illustrate things we are working on for the future such how to add and access extra attributes of your local users or why it makes sense to let SSSD handle smart card logins even for local users.

The talk will be useful to system administrators, mainly those who deal with user account management, but also to developers who work on services that integrate with user databases.

The talk will deal with topics including: - why we enabled SSSD in Fedora and in RHEL on all systems by default, even those that have no connection with a remote user database - why are we moving features like smart card management or even Kerberos cache management to SSSD - what are the interfaces that SSSD exports towards the system, both on the operating system level and the programming level - how can you use SSSD to fetch data from a remote data store to your application

Open Food Facts is a free, online and crowdsourced database of food products from around the world, licensed under the Open Database License (ODBL). It was launched in 2012, and today it is powered by 5000 contributors who have collected data and images for over 380 000 products in 178 countries.

Scan a product using your phone, take a picture, and you're already part of the Open Food Facts revolution !

In this talk we'll show how Open Food Facts leverages open source technologies such as Perl, MongoDB, Pastec.io, Android, Swift as well as the great power of communities to open data of public interest for health & science, as well as unforeseen applications in your daily life.

We will also introduce you to the recently launched Open Beauty Facts, for freeing your cosmetic cupboard: shampoos, toothpastes, lipsticks, etc.

How does it work?

Using our Android or iPhone app, you can easily scan the barcode of products from your home or local stores, to either check them out at a glance (thanks to the decoding and comparison tools) or to contribute them by uploading pictures of their labels. The same can also be done from the website, where additional tools are available to fill in the product details from the labels, navigate the database based on various criteria, make statistics and chart visualisations, or access APIs and raw data to make your own tools and analyses.

Open all the way

Open Food Facts is developed and managed by a community of open source, open data and food enthusiasts and is organised as a non-profit association. All its creations are open:

• the collected data is published as Open Data,
• the software running the server(s) is open source and reusable (it was also used to create the Open Beauty Facts database),
• the mobile applications are open source as well.

While Go is not primarily designed for parallel programming, it nevertheless has features that end up being beneficial for parallelism as well, especially the inclusion of a work-stealing scheduler for goroutines and a concurrent, parallel garbage collector. For this reason, we have recently included Go as one of several candidate programming languages in an evaluation of their suitability for expressing sequencing pipelines. Other programming languages we have evaluated were C++ and Java. Go hits a sweet spot of performing very close to the best results with little programming effort and few compromises in terms of safety and generality.

This talk will present highlights of this experiments and the most important insights.

A DNA sequencer takes a DNA sample, such as human tissue, and applies chemical processes to eventually read small fragments of the DNA sample and output them as large files. These files are then fed into software pipelines that reconstruct the original DNA sequence from those fragments, among other things. Such sequencing pipelines need large amounts of storage, on disk and/or in RAM, and can strongly benefit from parallel execution to improve runtime performance. Data sets for human DNA samples are usually in the order of several hundreds of GB of uncompressed data, and runtimes are typically in the order of several hours for single samples.

Go is usually presented as a language designed for concurrent applications, and it is usually stressed that support for parallel programming was not a major design goal. It may therefore be surprising to a larger audience that Go actually fares very well for parallel programming tasks, with relatively little effort. This talk may encourage Go developers to explore the language for application areas that can benefit from parallelism, beyond the domains where Go is typically used.

Please note that this talk replaces one entitled "Writing a structured syslog parser in Go" that was due to have been given by Brian Knox, who has sent his apologies but is now unable to attend FOSDEM this year.

According to Wikipedia, Community is "a small or large social unit (a group of living things) who have something in common". If we want to analyze any Open Source development community, it's key to understand the relationships of the people that define that community. Open Source communities provide many ways for peers collaboration beyond participation in forums and mailing lists. In any case, people graph or network analysis is one the methodologies used for social interaction analysis. During this talk, I'll show social network analysis with a free, open source software Kibana plug-in integrated in GrimoireLab. I started this project during my degree thesis, 6 months ago, and once it was released everything has changed. People started to download the plugin and contribute to it. Now, the repository hosting the plugin has more than a hundred thousand clones and a hundred of daily visits. The talk will show how to use the Network plugin in order to analyze open source projects. I'm going to show data retrieved from an open source project and I will show that with differents types of networks/graphs.

This Kibana Network plugin has, as the main aim, the integration of visualization systems of social networks in complex systems of visualization and data interaction based on open source. It relies on Kibana as a complex system of data visualization and ElasticSearch as the database. In order to integrate these visualization systems, a Kibana plugin has been developed to visualize this data in a social network way. The plugin is an open source project, uses open source libraries, and it is completly integrated in Kibana (using its components). Hence, it's integrated in GrimoireLab to allow social network analysis in open source development communities. The talk will show how to use, and create graphs with it. I will show how to import open source project data (e.g., commits, usernames, repositories, organizations, etc.) to ElasticSearch form GitHub (or other sources) using GrimoireLab. I will build a graph visualization from scratch, showing its features and usability. You will see how simple it is to create a network that relates users with repositories, organizations, etc. in order to show how a community is related in their own projects. Finally, the talk will explain how a graph/network can be integrated into a dashboard with other visualizations, and how to deal with real time data and filters in order to show what it's happen in the community instantly. Since I started its development, many people contributed, tested and downloaded it. As a consequence, the plugin has evolved and adapted to the community needs. The plugin has had a big impact in the ElasticSearch and Kibana community, and currently it has more than a hundred thousand clones and it receives a hundred of daily visits. Kickstarting and managing this open source project has been a great experience for me, and now I understand more how to contribute, get involved and improve a project in a big open source community. And I hope you can find it useful for your communities too.

• Network plugin

• Network plugin Repo

• GrimoireLab

Networking became a prominent aspect in Genode over the years. As common for microkernel-based systems the whole networking infrastructure, down from the drivers up to the socket implementation resides in the userland and comes in cleanly separated building bricks. Today, the framework provides various such building bricks to be combined into an individual solution for each use case. This includes components like an L2/L3-router component with NAT and DHCP functionality, a network-bridge component, a socket-filesystem server using VFS, NIC and Wifi-drivers, as well as libraries like the Lightweight IP and the Linux IP stack. The talk shall give an overview about the design of this ecosystem, how it can be used, how it evolved, and, last but not least, discuss its future.

SRv6 Network Programming on FD.io VPP and Linux

Tittle: SRv6 Network Programming on FD.io VPP and Linux

Description: Segment Routing is a new network architecture that leverages the source routing paradigm to remove state from the network. The IPv6 instantiation, allows to deliver a so called network program, where a packet traverses the network executing functions on different nodes of the network. This functions can be NPU-related functions, or it can be complex VNFs running in containers. In this way, we can leverage SRv6 for overlays, underlays and service chaining all from one single protocol. In this session we want to give a brief overview on SRv6, cover the SRv6 implementation in FD.io VPP, as well as showcase how to create your own network functions in VPP. Also, we would like to showcase how to develop SRv6 functions in Linux, and show the first-ever SRv6-aware app in the world: SERA, an advanced SR aware firewall, capable of taking stateless actions programmed in the SRH (Segment Routing Header).

Speaker: This workshop will be lead by two speakers.

Speaker 1: Pablo Camarillo is a software engineer in Cisco CTAO. He's one of the members of the core SRv6 architecture team and has developed the SR implementation in FD.io VPP. Prior joining Cisco, he was a research engineer at IMDEA Networks institute, where he prototyped a BGP route server in ExaBGP and researched on the algorithmic of TI-LFA (SR Topology Independent Loop Free Alternates).

Speaker 2: Ahmed Abdelsalam is a PhD student at Gran Sasso Science Institute researching on SRv6 for SFC in Linux. During his PhD he successfully completed an internship at Cisco Systems. He is CCNA, CCNP and CCAI certified.

Discussion of how and why we've revised our Community Participation Guidelines and how you might want to revise your own community guidelines or codes of conduct too.

In this talk we will present the technical challenges we have encountered while building an FM & web radio station from scratch and the innovative solutions that we have applied to them, utilizing open source software, and - where possible - hardware, as well as developing our own components, such as our software FM MPX signal generator, our producer-friendly GTK desktop application and many more. Furthermore, we will elaborate on the technical processes of building a music and sample library using open-source software and services, and how we utilize this library to produce an automated broadcast using our custom GStreamer-based audio clip scheduler.

The University of Crete (UoC) Radio Station is a non-profit, community-driven radio station developed primarily by students and alumni of the University of Crete, in the university’s campus. The station, as a community, is founded on the concepts of DIY and Open Source in all of its aspects, from the operation & organizational structure of the community to the very technical problems, where we choose to use open source, community-driven software, hardware and services and build things ourselves from scratch where it’s possible.

Bunnie Huang's "Guide to Shenzhen" is absolutely invaluable, but it assumes that you know exactly what you need to get, before you actually get it. If this isn't clear, for an example of exactly what the problem is, try an Internet search for "Laptop trackpad supplier". Did you find one? Did you find a source of trackpads for use in that laptop that you're thinking of designing? Or did your search queries instead get completely and utterly swamped with thousands upon thousands of aliexpress pictures of the EXACT SAME Apple Trackpad for a 13in Macbook Pro?

What about LCDs? Do you even know what type of LCD is commonly available right now? Were you aware that MIPI is Cartelled? Or that the people telling you that eDP is "The Future" are trying to push a much higher-power-consumption design at you and they forgot to invite China-based Manufacturers to the closed-door meeting. How can you actually find which LCDs are commonly manufactured and available in Shenzhen, so that you can begin the design right now before you take that expensive trip abroad.

And what about components? If you've looked on taobao or aliexpress, you'll know that many of them are rip-offs, there's absolutely no datasheets, the vendors make pittance so they're extremely unlikely to answer your questions... so what actual use is this resource, to anyone?

This talk will help answer the paradox of bridging the gap between Shenzhen market prices and the Western and Libre mindsets for hardware design, allowing attendees to take proper advantage of the lower pricing of Shenzhen-sourced parts, and to avoid the nightmare scenario of designing a PCB only to find that its parts went End-of-Life in the Shenzhen markets many years ago, and that the last remaining parts available must be bought from Digikey and IMPORTED (back into China from where they originated!) with a whopping lead time and huge import tariffs of up to 40 percent.

Availability of bleeding-edge and prototype hardware is always scarce. Local access to hardware is not always convenient to arrange when multiple members of a team are working on the issue across country and timezone borders. It would also be inefficient to allow much sought after hardware to idle when one team is not actively using it out of office hours for example, as traditionally happens when hardware is shipped. The author, who is currently working as one of the maintainers the Intel graphics i915 Linux kernel driver, has sought for an efficient solution when working as a home based employee for multiple companies. Some off-the-shelf solutions exist, but they're far off in the price range to be suitable for an average Open Source contributor. This talk will walk you through the gotchas in setting up an environment for your project and a demo of one system can be presented optionally.

Book production, from inception to publication, is still very much trapped in writing-correction-production cycles that resemble how software was made much earlier. However, productivity would be very much increased if the writing-correction-publication would be taken a step (or two forward) to a continuous integration/continuous delivery DevOps-like environment where you define by software the whole pipeline a book is going to follow from writing to publication. LitOps is a transpiling of the DevOps culture to book production, using mainly software development tools, and rigging them so that you can produce and publish quality-checked books using as many automation tools as possible.

Although most arts make extensive use of automation tools, from textures in comic to automatic motion generation tools in 2 or 3-d animation, writing a book, whatever its class, technical or fiction, gives the word manuscript its full meaning, since the most advanced tool used is the spell and maybe grammar checker. This leads to long development cycles, with new editions published after long rewriting-edition-production cycles. Nowadays, authors can publish directly using a variety of places, from Leanpub to Kindle Direct Publishing, and there are all kind of tools available for doing that kind of thing. Still, this has not lead to fast production cycles where new editions are produced as soon as "bugs" are found and fixed and all formats are published at the same time. My personal history in this area started when I decided to write a book from the first line using GitHub. That lead to using continuous integration, and it kind of ballooned from here. Nowadays I have created a full automation suite, in Perl6 and Python, that produces "printed" versions (shortening and expanding URLs), checks for line bleeds, and produces several high-quality formats from a Markdown source; time from change to new publication-ready version takes a few seconds. The only thing missing is an API for publication sites that would allow to make an automatic deployment. However, even without that final steps, the LitOps concept that codifies book production pipelines using scripts, including error checks and the rest, actually might mean a sea change in how fiction and non-fiction is produced, using LitOps teams and adopting the rest of the patterns of the software industry: forking, hackathons and linting, and finally taking manuscripting to this century.

While test automation is desirable in every software project, not all tests can be automated well, e.g. testing software that requires specific hardware. Furthermore, manual system tests often unveil unexpected faults simply because humans are more sensitive in this regard. Actually, almost every developer does this kind of manual tests "somehow". However, due to the lack of a proper tool support, these tests happen in an unplanned, unsystematic way and without documentation. As a result, it is hard for users to find out which features of a product were tested in which environment, on which hardware, and with which result.

We are working on a novel web application named SystemTestPortal for creating, running and analyzing manual system tests. The tool aims at being useful for developers, testers, test managers, and end-users. It is lightweight, written in Golang, available under the GPLv3 license, and developed in a student project. Many of its planned features are working already and it's getting steadily closer to a mostly complete 1.0 release.

This lightning talk will give a brief introduction and demo how the tool can be used to test a typical free software application.

The OpenSeaMap project is part of the OpenStreetMap project family and aims at leveraging crowd sourced information for leisure captains. As it targets a sepcific user and application group it also relies on additional data on top of traditionally used positional data. This presentation is about an effort to create a hard- and software platform capable of collecting the needed data for the OpenSeaMap project. We share early results yield with a prototype implementation of the proposed platform.

This presentation focusses on the hardware part of a platform prototype used for collecting data on a ship of a participant of the crowd sourced OpenSeaMap project. In combination with the software running on the proposed hardware platform and additional software parts running on the host of an participant and the server side software of the OpenSeaMap project the data is collected, processed, rendered and provided for download and use by the leisure boat captains. The platform is based on a RaspBerry PI and a HAT as well as a professional depth ranger. The project aims at developing a dedicated HAT for the purpose of OpenSeaMap data collection.

However, the current state of development, namely a productively used prototype and the plans for the next steps as well as some early results are shared with the audience. Further ideas and recommendations for improvements and next steps are very welcome.

In JDK 9 we made the G1 garbage collector the default OpenJDK garbage collector. Does that mean G1 is done? Definitely not! The Oracle GC team is working on exciting changes to improve throughput, latency and memory footprint for the G1 garbage collector for the next JDKs. We are excited to give you a heads up on a few of them:

• Faster Card Scanning
• Parallel Full GC in G1
• Rebuild Remembered Sets Concurrently
• Abortable Mixed Collections
• Automatic Thread Sizing

Of course, this is just what we are currently working on; we would also like to share a few interesting ideas that would be interesting to pick up and contribute. :)

Prometheus' exposition format is great, but its adoption is limited, in part, by political considerations. Creating an industry standard which is detached from Prometheus will hopefully help alleviate this issue.

Have you ever wished you could see how exactly a user broke your server? Have you wished to see how the user stumbled upon the problem they just reported? Would you like to have such a power within your easy reach, right in your browser, without the need for a pesky command-line setup? Wish no more, because we're going to handle that with User Session Recording support in Cockpit!

As part of our User Session Recording project, Red Hat Common Logging team is working with developers of Cockpit, a server management Web UI, to implement support for configuring recording, searching, correlation, and playback of users' terminal sessions, all in your browser! On this session we are going to introduce the new effort, show what's working already, present further plans for development, answer your questions, and eagerly listen to any feedback you might have!

The Red Hat's User Session Recording project is aiming at building an enterprise-ready solution for centralized recording of user sessions, for audit, forensics and compliance purposes. The solution involves integration with Linux audit logging system, FreeIPA identity management, Elasticsearch storage, and integration into UIs of various management solutions, such as OpenShift, CloudForms, etc. As part of developing our playback and correlation UI component, we're implementing Session Recording support in Cockpit.

Cockpit is a feature-rich server management Web UI with a new twist: it doesn't take over your system and doesn't force you to relinquish direct control over your system. Instead it lets you jump freely between the command line and the browser at any time you want. You can immediately see the changes you did on the command line in your browser and vice versa. That facilitates gradual learning and simplifies complicated tasks. Cockpit supports a variety of Linux distributions and releases, does its own releases very frequently, and achieves that via advanced and comprehensive continuous integration system, which is a wonder on its own.

A lot of developers consider that a language is only as good as the tooling that accompanies it. Ada has been conceived as a language pretty well amenable to tooling, yet the tooling offer besides AdaCore's is not very extensive, at least when compared to other languages like Java, despite the existence of the ASIS project (Ada Semantic Interface Specification).

One of Libadalang's aims is to help solve that by providing an easy way to build new Ada-aware tools. Libadalang is a library that allows the user to query information about Ada code, including: Syntactic information. Query the token stream, the syntax tree, find syntax patterns, etc. Semantic information, such as which declaration an identifier references, the type of expressions, all references to a declaration, etc.

In addition, one of the aims is to allow the users to modify the trees, and propagate the changes to the source.

This talk will go over what Libadalang can already do today, how it differs from ASIS, future plans for the library, and potential exciting use cases.

Traditional logs are okay for humans to read, but when the sheer volume of information generated is too much to be processed by a human being everything falls apart ... add distributed systems into the equation and you are pretty close to hell. Structured-logging proposes to take a bit more time when writing logging statements to make it easier to extract and process all this crucial information. Thanks to the rich log entries, new insight can be reached to understand the systems.

In this talk I will talk about structured-logging and show how useful.

Will cover : - limitations of string-base logging - different approach : structured logging

The EU-FOSSA project developed by European institutions is aiming at improving the security of Open Source Software. The next iteration of the project, EU-FOSSA 2, is continuing in 2017-2019 with a higher budget of 2.6 M€ and a novelty, the bug bounties. Information about the planning and status of the project will be given during this talk.

The EU-FOSSA project is aiming at improving the security of Open Source Software. The first iteration of the project was executed during 2015-2016. This project:

• developed a methodology to perform code reviews at the EU institutions,
• performed an inventory of Open Source Software used in the European Commission,
• reviewed code of Apache HTTP Server Core and KeePass, with the help of an external company.

In the new iteration of the project, running during 2017-2019 with a total budget of 2.6 M€, we explore the possibility of using public money to fund bug bounties. This way the European institutions intend to improve the security of major Open Source Software to reduce the risk of a new major incident like Heartbleed. We also intend to convince everyone that this should become a permanent activity of the European Union.

We are also planning other activities, like more active communication and direct collaboration with open source communities. The peak of activities is expected during Q3/2018 - Q2/2019. The timing of FOSDEM18 is a perfect opportunity to inform everyone interested in the project about the status and the activities planned.

We will have open discussions about RISC-V ecosystem after Palmer Dabbelt talk: Igniting the Open Hardware Ecosystem with RISC-V.

FFmpeg is a FOSS, cross-platform, solution to record, convert and stream audio and video. This session will focus on using the CLI tools included in this project [ffmpeg and ffmprobe] to accomplish everyday video manipulation and streaming tasks.

The session will include a live demo showing how to achieve the following goals:

• Extract metadata from video and audio files
• Convert between different media types
• Live Stream over RTMP
• Record screen display
• Basic editing operations [concatenation of several video files into one, extracting the audio track from a video, etc]

Infinity is a platform-independent system for executables and shared libraries to expose functionality to debug, monitoring, and analysis tooling. It grew from a need to be able to debug multithreaded applications without requiring libthreaddb. Other systems exist that use the libthreaddb paradigm, for example librtld_db and OPMD; Infinity was designed to replace this entire class of library-tool interface with something more portable and robust.

Covers: * What is Infinity? * Motivation for creating it * Status of tooling and glibc/GDB integration * Mini code walk through (libthread_db vs Infinity) * Demonstrations! * Potential future uses

High-performance flash storage like NVMe SSDs are becoming commonplace in production environments. In this age of fast storage, inefficiencies in storage software stacks that were previously acceptable with slow spinning devices, are no longer tolerable. There are even faster technologies, like NVDIMMs, on the horizon. These developments are particularly challenging for distributed storage solutions like Gluster and Ceph, where network latencies are a fact of life. This talk is on performance analysis and troubleshooting tools and techniques for this age.

In this talk, we will share some of our experiences in driving performance improvements in gluster to enable it to better deliver the performance of fast hardware devices to applications that need it. We will cover our performance analysis methodology and some of the common problem areas we see as we try to scale in performance. We will discuss some of the tools available for troubleshooting performance bottlenecks, like perf and mutrace. But tools alone are insufficient to troubleshoot performance issues and we will share some of the techniques that we employ to get the needed insights from our tools. We will present examples for how instrumentation in the code is sometimes invaluable in identifying performance issues.

In this talk I'm going to present Terra Bruciata, an open source initiative aimed to bring hi-integrity techniques in the world of open source with the objectives of (i) providing to the world bug-free software (ii) developing hi-integrity techniques suitable for open source and (iii) showing to the world that bugs are not unavoidable...

Software bugs are everywhere and they brings much harm. History is sprinkled with software horror tales: race condition in radiation therapy machine Therac-25 caused deaths and injuries, badly written automotive software caused unintended acceleration, bugs in the entertainment system allowed an attacker to take remote (full) control of a car, software glitches caused (many times) chaos in the stock market and so on... Unfortunately many think that bugs are like bad weather: annoying, but unavoidable, so that the only solution is to have patience and bear with them.

However, I agree with late Robert Dewar when he says that we should not put up with them. With the future advent of IoT, putting up with glitches it is an open invitation for the Software Apocalypse. Therefore, I decided to start Terra Bruciata, an open source initiative whose goal of is to bring a software correctness mentality in the open source community. We will try to adapt to an open source context procedures and good practices from standards like DO-178 and using techniques such as formal checking. We will initially concentrate on libraries for network protocols. Although this choice can seem strange, it has its rationale. First, network protocols are pervasive nowadays and a bug in a network library can easily become a security hole. Moreover, the IETF has the desire to improve the involvement of open source communities and academia in protocol developments and this initiative could be an interesting channel for that. The initiative just started and as first protocol we choose CoAP, the Constrained Application Protocol, a kind of lo-weight HTTP, developed having in mind small devices IoT-style (yes, it is fashionable...)

The last hour of the day will be dedicated to lightning talks. Come watch great short talks, or come present yours!

This talk will explore mistakes everyone makes when trying to bring one or more communities together. Instead of starting from scratch, and creating a new community for every single cause, this talk will explore how existing communities can be brought together, if there is room for cooperation between projects and if the founders are ready to set their egos aside. It be based on the case study of the Social-Digital Innovation Initiative, which aims at bringing social good and tech together, also through communities.

Bringing communities together worldwide is hard, and it's especially hard to bring two completely different communities together. We at the Social-Digital Innovation Initiative are doing it step by step, country by country, region by region, trying to build bridges between people trying to solve social problems (i.e. social entrepreneurs - the word social doesn't refer to social networks here) and those who know how tech could help. All this happens offline at barcamps and online, on our discourse. But is this really the most efficient way? Do you always have to set up a new community for a cause or a project? Or is it inevitable because people need to feel like they belong - and projects need to measure their impact? What if we stopped trying to set up communities for each and every little project, put the founders' egos aside and teamed up? Could we bring existing communities together cooperatively and help them cross-pollinate?

The current EU copyright reform proposal puts pressure on platforms to monitor and filter all content, including uploaded FLOSS software, for copyright infringement (article 13), proposes a new 20-year license for news snippets (article 11), and limits who can access datasets -- including open data. Any of these would be terrible outcomes. Let's demand better copyright reform.

“In the near future, it will become possible to book a commercial space flight — a sub-orbital trip to any destination you like. Think of how complex the laws will have to be when space flight goes from something done only by a few, to anyone, and eventually everyone. Now imagine if we decided to govern that industry by taking the Highway Traffic Act and adding the words “in space”. This is a lot like how we’ve updated copyright law for the web. Mostly, we just took the old law, and added the words “digital” and “online”. And that's worked out just about as well as you’d expect it to." (Ryan Merkley, CEO of Creative Commons)

The current EU copyright reform proposal puts pressure on platforms (which is badly defined, so includes sites like Gitlab, Github and SourceForge) to monitor and filter all content for copyright infringement (article 13), proposes a new 20-year license for news snippets (article 11), and limits who can access datasets -- including open data. Any of these would be terrible outcomes. Let's demand better copyright reform.

In this session, representatives from Mozilla's Policy team will tackle the following questions:

• What's happening with the EU Copyright Reform?
• How will Articles 11 + 13 affect the Internet experience in Europe?
• How will the proposed reform affect the FLOSS ecosystem in Europe? The rest of the world?
• Why is this happening?
• What is Mozilla doing about it, and what can we do about it?

Why should you care? Because we believe in "default open"; because we want to grow the open source community, and because the internet continues to be in danger of being ruled by politics.

(Disclaimer: we won't be discussing the right of governments or the EU Parliament to propose or enforce internet regulation. We're working within the existing system, not against it at the moment.)

Please note that this talk was originally scheduled to be given by Melissa Romaine who is no longer able to attend. It will now be given by Giannis Konstantinidis and Gervase Markham.

We decided to build one solution from scratch that fully adapts to our needs and lets us take control over all layers involved. We tuned network, storage, hypervisors performance and viewers, focusing in desktops templates quick deployment.

In this talk we will focus on the experience over the past years developing our own VDI system that brings virtualization at Escola del Treball in Barcelona with over 1k users and 2k desktops created. We had a low budget so we used gaming hardware and cheap second hand hardware that we had to optimize.

IsardVDI is an open source project that is currently deploying desktops quickly while using low cost servers and network infrastructure. We had to optimize that hardware, from storage IOPS to real time UI events, while keeping in mind network traffic and system reliability.

We use NVME to do write-cache, 10 Gbps copper networks, gaming mainboards, mainstream processors, raspberry pi and old computers as thin clients. We built NAS in cluster systems with pacemaker and drbd, incremental qcows disk storage to lower storage footprint. Hypervisor statistics about use and resource consumption brings orquestration oriented to desktop performance.

IsardVDI can be quickly deployed with docker containers. Some of the technologies used are Libvirt, Spice, EnhanceIO, Pacemaker, DRBD, Python3, WebSockets, RethinkDB, ...

Wayland is the most advanced X11-alternative display protocol, shipping today in a variety of desktop and embedded environments. Although the Chromium browser on Linux still defaults to use the X11 window system, there have been efforts to port it to different environments.

This effort happens in various fronts, including the development and stabilization of Ozone, an abstraction layer for graphics and input events, and the transitioning of some ChromeOS-oriented solutions to Linux, for example Chromium's new "UI service".

Igalia has been actively contributing to this multi organizational collaboration, aiming at getting a full fledged Chromium browser running natively on Wayland. The work happens on Chromium's upstream repository so that the greater Chromium community can benefit from it.

This presentation intends to show the Chromium project's way to Wayland.

Wayland, the next-generation display server protocol, is slowly but surely taking over the Linux desktop. Preexisting and new applications will have to adapt to this new environment that is fundamentally different from how things used to work on X11 for a long time. This talk gives you the basics of programming native Wayland clients in 2018: the Wayland architecture and protocol world including recent developments, what you can and cannot do, the steps to get something visible on the screen, and why you might not want to do a native application after all.

The presentation is intended to give a conceptual overview of things that any Wayland client programmer will have to look at. The architecture and design of Wayland will be shown and compared to X11. However, rather than porting applications from X11 to Wayland, the focus here will be on building native Wayland programs from the ground up. The Wayland ecosystem and relevant compositors will be described and suggestions for testing will be given. Furthermore, the process of getting a surface to the compositor for drawing it on the screen will be explained and all basic protocols needed for this such as the global registry, shared memory, surfaces, and shell surfaces including xdgwmbase will be introduced.

The talk will not go too deeply into programming specifics and the libwayland C API, but some common pitfalls and best practices will be mentioned.

I've been teaching an undergraduate "Unix for Software Developers" class at the University of Applied Sciences, Darmstadt, Germany for a number of years now. The last three years of them in English to allow exchange students to participate as well. I am using FreeBSD in my class and the lab exercises. Topics of the class include an introduction to the Unix shell, editors, filesystems (with a big focus on ZFS), shell programming, grep/sed/awk and since 2017, I also added Ansible. In this talk, I want to reflect on what I learned interacting with the students of various (Unix) backgrounds. I also want to discuss with the audience how to improve the class with relevant topics so that the students get the most out of the class and for their later Unix careers. I'll provide an insight into my labs and what we do there with FreeBSD, too.

Work on the automatic updater for LibreOffice has progressed and daily builds with the updater are provided already for Windows and Linux. However, the updater will not be available in the 6.0 major release. We will explain how the updater works, which problems have been addressed already and what still needs to be done.

The LibreOffice automatic updater currently under development is based on the Mozilla mar updater code. The integration of the code was started as a GSoC project in 2015 and has seen more work since the end of 2016. Since mid of 2017 daily builds are available that contact the new LibreOffice update server and provide automatic updates. The distributed updates include full updates as well as differential updates depending on the age of the builds.

During the talk we will start by discussing the updater server infrastructure and show how the new code allows to collect a number of metrics that help the whole project. Next, the client side with the integration of the mozilla based mar code will be discussed. This includes the already existing features and an explanation how existing updater builds are already generated. Finally, the challenges that are still ahead will be shortly outlined, including a short demo showing the new MSI update file generation code.

I'm going to talk about new features of upcoming Graphite 1.1 release - what's new and why it's still usable in 2018. The talk will be useful for current (and former) Graphite users and all persons interested in metrics/TSDB area.

Graphite was one of the first "kick-ass" tools which helped to start #monitoringsucks/#monitoringlove movement. In 2018 it's a bit outdated, but still alive and kicking.

Upcoming Graphite 1.1 will have some nice features: * Tag support (with (upcoming) Prometheus and Grafana integrations) * Python 3 support * Custom (user defined) functions * "pipe" function chaining syntax * Updated cluster request handling * xFilesFactor-in-functions support * overhauled aggregation functions * msgpack support and many others.

In this lightning talk the objective is to share actual implemented ideas that have helped financed the XWiki and Cryptpad open source projects without external capital. For now 14 years, XWiki has been able to self finance writing Open Source code and sharing it with the community. We will quickly share what has worked or not, what has proven difficult, what is tricky in order to keep the Open spirit and what has been miraculous !

In this lightning talk the objective is to share actual implemented ideas that have helped financed the XWiki and Cryptpad open source projects without external capital. For now 14 years, XWiki has been able to self finance writing Open Source code and sharing it with the community. We will quickly share what has worked or not, what has proven difficult, what is tricky in order to keep the Open spirit and what has been miraculous !

XWiki is and Open Source software created 14 years ago by Ludovic Dubost and developed under the LGPL licence. The XWiki software is used by thousands of companies to help them organize information. CryptPad, created by the XWiki team in 2016, is a realtime encrypted pad allowing to share information without exposing your content to your cloud provider. These software have been possible by finding ways to have the XWiki team paid to write open source software, which we will share in this lightning talk.

An open Q&A session with members of the OpenJDK Governing Board.

An open Q&A session with members of the OpenJDK Governing Board.

This talk will showcase how FOSS design tools such as FreeCAD were used during the WikiLab project in São Paulo, Brazil, and how this can change the game in the construction field.

The WikiLab is a collaborative construction based on the WikiHouse project, that started in São Paulo, Brazil, in 2017 and is still occurring, being a continuous experience. The construction was done mostly by a team of volunteers, it mixes architecture, CNC manufacturing, collaborative planning, construction and management, ecological, technological and social research, and the whole design was done completely with free software, mostly FreeCAD. In this talk, I'll try to showcase how the use of free software had a very special impact on the project design and construction, how this reaches areas where no commercial software entered before, and how this can change the way we do architecture.

We think Metrics and logs are not that different. Do you agree?

This was our statement when searching for a unified monitoring solution with real-time analytics,

for the oVirt data center virtualization project.

This talk gives an introduction on how to integrate oVirt metrics with the EFK stack on top of OCP.

Attendees of this session will be able to get an in depth look into the stack architecture and ways to utilize it in open source projects.

We think Metrics and logs are not that different. Do you agree?

This was our statement when searching for a unified monitoring solution with real-time analytics,

for the oVirt data center virtualization project.

Using Elasticsearch and its native visualization layer, kibana, we aspire to provide the oVirt project users a fully functional monitoring solution.

When combining this stack, built on top of OpenShift Container Platform (OCP),

with client side daemons such as collectd and fluentd, we get an end-to-end powerful open source solution.

This talk gives an introduction on how to integrate oVirt metrics with the EFK stack on top of OCP.

Attendees of this session will be able to get an in depth look into the stack architecture and ways to utilize it in open source projects.

We want to share a couple of stories where hardware design choices designed to improve system security actually turn out to provide the contrary. This especially becomes prevalent in modern microkernel systems where the workaround for these design choices strongly contradicts the goal to reduce complexity.

How to help users progress from filing bad issues to filing good issues to making simple contributions to making complex contributions to maintaining your open source project. Talks about the open source contribution funnel through which people progress and the best tips for maintainers and contributors to attract and retain more of them on a given project.

Informal discussion on ideas and proposals for future events.

In Kaltura we use REST API for every external and internal interaction and integration. As online video platform we work with media files combined with textual REST API and we would like to share the lessons learned.

Please note that this talk was originally scheduled at 11:00.

How to upload media files using textual REST API? How to download video, audio, images, close-caption and other media content using REST API? How to manipulate video and images using REST API?

This talk will go through what Fleet Commander is (and, consequently, what Fleet Commander is not intended for), which are the solutions proposed by the project, how Fleet Commander interacts with SSSD and freeIPA and, plans for the future and finally provide a Demo of the current state of the project.

The talk will be divided basically in 4 parts:

1) Describing what Fleet Commander is (and what it's not intended for): Fleet Commander is an integrated solution for large Linux desktop deployments that provides a configuration management interface that is controlled centrally and that covers desktop, applications and network configuration. Last but not least, Neither Ansible nor Puppet could solve the core problems of Desktop Session Configuration Management, which is what drove the Fleet Commander development.

2) Describing Fleet Commander interaction with freeIPA and SSSD: Fleet Commander relies on freeIPA, which provides a standalone plugin for desktop profile management, to store the profile data and its assignments to users, groups and hosts from the administrator point-of-view. From the client point-of-view, Fleet Commander relies on SSSD to fetch the the profile data at users' login time and notify Fleet Commander whenever new profiles have to be applied.

3) A short Demo about the current status of the project: This will be the first time that Fleet Commander project will be Demo'ed after the freeIPA/SSSD integration.

4) Plans for the future: A quick discussion about what are the plans for the future, including a way to manage profile data in case of direct integration between Linux clients and Active Directory servers (GPO is the key here!)

Bugmark is a market that connects people who want better software to people who can build it. In order to make open collaboration more effective, we are using simple market mechanisms to add incentives to do useful work.

With Bugmark, users can:

• Put financial value directly in the hands of the people who can fix the software issues that are most important to you.

• Discover which issues really matter to yoru project's users.

• Work with open source practices and not against them. Solve part of a problem and still get paid, instead of contending to claim credit for a bounty payment.

A lightning-fast introduction to Grafanalib, a small Python library that lets you create dashboards as code.

Target audience for the library is people using and amending Grafana dashboards, but the underlying idea is of interest to anyone doing Ops or DevOps.

Grafanalib is an Open Source Python library that lets you create dashboards as code.

Once your dashboards are code you can check them in, PR them and have a CI/CD pipeline - GitOps!

Talk will cover:

• Basic primitives in the library - YAxis, Graph, Tooltip and so on
• Higher-level components such as QPSGraph
• Build your own components such as a LatencyGraph or a REDRow.
• How to deploy dashboards created using Grafanalib

GStreamer is a complete Open Source multimedia framework, and it includes hundreds of plugins, including modern formats like DASH, HLS or the first ever RTSP 2.0 implementation. The whole framework is almost 150MB on my computer, but what if you only have 5 megs of flash available? Is it a viable choice? Yes it is, and I will show you how.

Starting with simple tricks like only including the necessary plugins, all the way to statically compiling only the functions that are actually used to produce the smaller possible footprint.

Ever hooked up a Linux Computer to a monitor only to experience...nothing? DP is far from being a dumb cable and requires that the entire graphics stack works together to gracefully handle mode failures and recover them. Achieving DP compliance requires that the kernel drivers, hotplug events and the userspace compositors all work together to render every frame at requested rate e.g by handling link failure. The Linux Kernel's atomic modesetting infrastructure on the other hand is a daunting beast of its own and understanding how all the pieces interact is a challenge itself. In this talk Manasi will present the ultimate technical solution for DP compliance ensuring a successful modeset that is recently upstreamed in Linux kernel (4.12) as well as Xserver (1.19.3)

If you’ve ever hooked up a Linux computer to a DisplayPort monitor or daisy chained multiple DP MST monitors and encountered only a flickering or blank screen, then the recent Linux Kernel update will fix it for you. DP is far from being a dumb cable and requires that the entire graphics stack works together to gracefully handle mode failures and recover them. Achieving DP compliance requires that the kernel drivers, hotplug events and the userspace compositors all work together to render every frame at requested rate e.g by handling link failure. The atomic kernel modesetting infrastructure is based on an underlying assumption that "Atomic check guarantees the requested mode and that commit should never fail". Although this holds good in case of all GPU parameters checks and commits, it does not validate the DP physical cable and DP link training failure can result in an atomic commit failure resulting into black screens. This talk will educate folks on the fix that was required to handle these atomic modeset failures in case of display port and how that was implemented across the entire graphics stack making it display port compliant. This solution was upstreamed to Linux kernel 4.12 and Xserver 1.19.3. through this talk Manasi will also share her journey through iterating designs and working together with upstream maintainers, collaborating with X-server community and finally designing and upstreaming a solution that is used by i915 and can be incorporated by all other open source DRM drivers.

FOSSology is a popular tool for the end-to-end analysis of software components in a single Web server application. It can scan source code for: a) License information, b) Copyright notices, c) Export control relevant statements. It makes software analysis more efficient by offering high precision, greatly reducing overhead costs. FOSSology lets users generate compliance documentation according to the organization's needs, in a variety of data formats, emphasizing SPDX tag-value and RDF documents.

FOSSology is Open Source Software licensed under GPL-2.0 and a Linux Foundation collaboration project. In the past year, FOSSology has improved in many areas such as reporting, license management and data exchange capabilities. This talk provides and update about The SPDX Import and Export Functionality.

License proliferation, the growing number of open source components and the heterogeneity within large open source components require thorough license analysis. Text or regular expression scanners are often not enough to get a precise picture of the licensing situation. Precise license analysis can occur when legal cases arise as well as when important product decisions must be made. The trade-off is the effort to invest in order to achieve a precise analysis.

FOSSology is a component analysis for license, copyright and ECC statements analysis, offering a high recognition precision. It allows for capturing exact license text wording for SPDX reporting. At the same time, aggregated views provide efficiency. Automation functionality enables effective workflows. Most recent points are the SPDX export functionality and the recently added the SPDX import.

FOSSology is an open source project since 2008, originally contributed by HP. It is licenses under the GPL-2.0 and is freely available for all, companies, organization and open source projects.

In which Leslie and Laura provide the concluding remarks for the day.

Today, many new programming languages have been created in order to simplify at the extreme the art of programming (Golang), to boost the performance of their human readable application (Nim), to secure the way to make and run programs with zero-cost abstraction (Rust), or just to propose a new exiting way to write programs (Scala, Swift), etc. Each of those new programming languages has its own features, goals, attendance, and community.

Today, it may become hazardous to develop with a new programming language, especially for a company or for a full-time personal project, due to the lack of stability, libraries, IDE features for this programming language, a too small or strict community, or many other obvious reasons.

The goal of this presentation is to introduce the concepts of Rust, its pros and cons, and how Rust differs from the others programming languages. The target audience is mainly for developers who are reluctant to launch themselves into Rust, or project managers and CTOs who are looking for stable and exciting new technologies.

This talk is intended to emphasize Rust rationale, and will explain clearly and precisely why Rust wants to be the programming language of the next ten years.

In this session, Steven Goodwin will practically demonstrate the various "moving parts" necessary to build a WebRTC application, by creating one live on stage. It will provide a better understand of how WebRTC applications work under the hood, what the API provides, and serve as a guide as to what is (and what is not) possible for developers to deliver using WebRTC, and what other technologies are needed for a full-blown solution.

The talk covers:

• History and scope of WebRTC
• The connection flow
• API functionality (e.g. stats)
• Creating signalling
• Server-side work
• The browser problem

It also details the business logic cases of how to take a basic WebRTC app and then to build a purely online VoIP product, such as a call centre, thereby demonstrating the extra work required to work with WebRTC, beyond the promotional blurb.

The goal of this talk is to introduce programmers with C++ experience to tool building with LLVM. My expectation is people know C++, have heard of, but not used LLVM. Examples provided on the slides will be small but useful snippets, and it is the expectation you will be able to build the examples provided within a few hours.

Introduction to the containers devroom.

As kubernetes clusters take on more workloads, the need for persistent storage has only increased. Users want to connect more storage devices and use them efficiently. Cinder has been solving this use case in Openstack for a long time and can be integrated with any kubernetes cluster regardless of its cloud provider. By deploying a standalone cinder service and a new external provisioner to a cluster, pods can access almost any volume that cinder is able to provision. Complex operations such as cloning, snapshots, and migration become services of the cluster. This presentation will describe and demonstrate a cinder external provisioner, enumerate its advantages, discuss challenges especially around deployment, and propose collaboration opportunities between Openstack and kubernetes.

DNS is the backbone of the Internet. When one is not able to access to a content (such as a website), the first thing to do is to verify the DNS connectivity. This talk will provde an overview of an open source DNS checking tool called "Zonemaster" (https://github.com/dotse/zonemaster), developed and maintained by Afnic (www.afnic.fr) and IIS (www.iis.se). The talk will further delve into the architecture, different components (Engine, API, GUI, CLI) and its usages for different end-users such as general users, Companies operating DNS, Companies having a DNS portfolio of domain names and DNS geeks.

The main design features of the tool include: * Parallel execution * Event driven mechanism * Distributed architecture And a: * Declarative, Functional, Reactive programming language.

The tool has two main parts: the engine, and the language. This presentation will demo both and include many interactive examples showing you how to build reactive, autonomous, real-time systems. Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

The main design features of the tool include: * Parallel execution * Event driven mechanism * Distributed architecture And a: * Declarative, Functional, Reactive programming language.

The tool has two main parts: the engine, and the language. This presentation will demo both and include many interactive examples showing you how to build reactive, autonomous, real-time systems. Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

A number of blog posts on the subject are available: https://ttboj.wordpress.com/?s=mgmtconfig Attendees are encouraged to read some before the talk if they want a preview!

Apertis is a Debian-derived platform for infotainment in automotive vehicles.

Being a Debian derivative, Apertis doesn’t use typical Debian infrastructure software, so a infrastructure to build it had to be created using Jenkins, Open Build Service and other tools to provide continuous integration and package and image builds. Having managed the build infrastructure of Apertis for some time, I’m going to share my experience about the challenges of working on it, and how we solve issues we are confronted with.

Once again, we meet in Brussels, at FOSDEM, to talk about the state of free software SDR. The intro will recap the year, and give some updates on what's new and great in the SDR world.

Welcome to and overview of the seventh year of the Legal and Policy Issues devroom

Object Storage is a "relatively" new storage architecture being widely used in cloud computing. This talk will introduce object storage concepts and use cases and how they are different from block and file storage. As an example, we will provide an overview of Openstack Swift, its main features as well as talk about what's in the works for future releases. Swift is a highly available, distributed, eventually consistent object store. It is used at organizations like Wikipedia, OVH, Ebay and many more across the globe to store lots of data efficiently at a massive scale. It provides a RESTful API for data access, making it ideal for use with web applications. This talk will also provide a demo usage of Swift.

Outline

• Introduction
  • Different types of data
  • Differences between block/file/object storage
• Use Cases
  • What use cases is Swift object storage built for?
• Requirements
  • What are the requirements for a modern object storage system
• Swift
  • Community
  • Swift architecture
  • Swift features
  • Future work
• Questions

Length: 30+5

An automated approach for documenting a styleguide and the source code

Introduction

This talk is about how, we at Zalando Retail Core, are tackling the problem of providing our developers a great experience when they are using our styleguide. The talk will show that in using Markdown as the documentation format, a couple of convention, documentation.js for generating Markdown from jsdocs comments and our own Styleguide web application, we were able speed up our styleguide and source code documentation and the developer experience. Additionally, without relying on any static generator project with their own convention we are now able to fully control and change the user experience of our styleguide and are owning the whole documentation tool chain.

An automated approach for documenting a styleguide and the source code

Introduction

This talk is about how, we at Zalando Retail Core, are tackling the problem of providing our developers a great experience when they are using our styleguide. The talk will show that in using Markdown as the documentation format, a couple of convention, documentation.js for generating Markdown from jsdocs comments and our own Styleguide web application, we were able speed up our styleguide and source code documentation and the developer experience. Additionally, without relying on any static generator project with their own convention we are now able to fully control and change the user experience of our styleguide and are owning the whole documentation tool chain.

Details

As part of the talk , I want to show attendees:

• The benefit of using Markdown as a shared data object for documenting
• tightly Coupling documentation of our to the repository and the domain instead of separating it into different projects. Documentation for React components is part of their JSDocs, a dedicated docs/ folder for creating high level description (How to use it the component vs. it's internal methods and API).
• How relying on Markdown helped us reduce the maintenance cost as we were able to involve also our UX designers -> shared ownership thanks
• How having full control on behaviour of the styleguide web application helped us to develop our own design and implement it as a normal web application rather then providing templates an understanding API's of existing static site generators.
• We take our documentation serious and therefore any PR needs to update the documentation (if necessary) -> PR templates are really helpful here.
• Using a CI solution helped us also to automatically build generate and test our markdown files, check if our styleguide application is working with these new applications (regression testing of our app)

The talk will be about our decision process and our current workflow in generating up-to-date documentation as part of the development process.

Before scientists can use HPC systems for their research, they need to get the tools and applications installed that they require.

Until recently, this was a (perhaps surprisingly for some) painful process, especially for scientists that lack sufficient experience with compiling software and dealing with dependencies.

Recently, several projects have emerged that aim to facilitate this process, each of which with a particular focus: performance, flexibility, reproducibility, ease of use, support for multiple platforms, etc.

In this talk, I would like to present an objective comparison of the different tools that are most prevalent currently, including:

• conda
• EasyBuild
• Guix
• Nix
• Spack

Although I intend to focus on the use case of installing (scientific) software on multi-user HPC systems, I will also highlight particularly interesting features that fall outside that scope.

Welcome to the Decentralized Internet Devroom (DID)

This is the second edition of this Devroom, which has been extended its topic to include privacy-related projects.

During this session, we'll discuss two topics:

1 - Why do we need do redecentralize the Internet? 2 - How and with who will we do it?

Ask Mozilla TechSpeakers your public speaking, conference- and CFP (call-for-proposals)-related questions at the Mozilla booth, hear some tips & tricks about public speaking and some inspiration for nailing your next conference submission.

Cannot make it to the Global Diversity CFP Day Brussels workshop? Or do you simply want to ask a few questions about public speaking or writing conference proposals? Drop by the Mozilla booth on Sunday, February 4 at FOSDEM between 10:00-12:00 and 14:00-16:00 and as talk to some seasoned veteran Mozilla TechSpeakers about public speaking, or ask them questions about public speaking/cfp-s in general or your talk (idea).

FREEWAT (FREE and open source software tools for WATer resource management) is an HORIZON 2020 project financed by the EU Commission under the call WATER INNOVATION: BOOSTING ITS VALUE FOR EUROPE. FREEWAT's main result is an open source and public domain GIS integrated modelling environment (the FREEWAT platform) for the simulation of water quantity and quality in surface water and groundwater with an integrated water management and planning module. The modelling environment is designed as a composite plugin in QGIS v2.X. It comprises tools for the analysis, interpretation and visualization of hydrogeological and hydrochemical data and quality issues, also focusing on advanced time series analysis. It interfaces models related to the hydrological cycle and water resources management: flow models, transport models, crop growth models, management and optimization models. And it contains tools to perform model calibration, sensitivity analysis and uncertainty quantifications. Finally, the some additional tools are present for general GIS operations to prepare input data, and post-processing functionalities (module OAT – Observation and Analysis Tool).

Capture the GDPR with Identity management A new era of Data Privacy begins this year and May approaches unstoppably. The media present the GDPR on a daily basis in volumes no one has expected. The whole commercial sector is hyped with articles about the GDPR, recommendations, warnings and in the end MYTHS! The GDPR is not only multinational corporations’ concern any more. Individuals and small entrepreneurs are looking for the answers too. This makes space for speculations and many partial solutions are offered in a form of a GDPR project draft templates or migration of processing into the new safe environment without appropriate paperwork. Even software solutions usually offer only partial safety measures and you will need a bunch of them to fulfill the GDPR project. A complete solution exists only as cooperation of legal person analyzing interpretation of EU legislative and IT technician able to incorporate those requirements into daily operations. The complete solution still does not mean 100% compliance because there are so many threats you can never be utterly safe from. This presentation will tell what you must not omit to be compliant, how to give effects to the rights of data subjects and how to craft your GDPR solution. We will discuss lawful basis for data processing, consent requirements and tools able to manage them effectively. In the end, we may think about the design of identity management tool that combines the advantages of identity management into one solution dealing with various GDPR issues. Included GDPR areas in light of Identity management: Lawful basis and consent management, risk assessment, data breach tool, DPO’s control tool and data subject’s rights control tool.

I intent to speak about how to think about GDPR solution, what is required and how to achieve it by either customizing existing tool or designing a brand new tool of your own preferences. As a lawyer working amid programmers, in this speech I will be considering both fields of view and looking for conjunctions. Touched areas of speech are lawful basis management, consent management, risk assessment, data breaches, DPO and rights of data subjects.

MySQL is unique in many ways. It supports plugins. It supports storage engines. It is also owned by Oracle, thus birthing two branches of the popular opensource database: Percona Server and MariaDB. It also spawned a fork: Drizzle. You're a busy DBA having to maintain a mix of this. Or you're a CIO planning to choose one branch. How do you go about picking? Supporting multiple databases? Find out more in this talk.

MySQL is a unique adult in many ways. It supports plugins. It supports storage engines. It is also owned by Oracle, thus birthing a branch and fork of the popular opensource database: Percona Server and MariaDB Server.

You're a busy DBA thinking about having to maintain a mix of this. Or you're a CIO planning to choose one branch over another. How do you go about picking? Supporting multiple databases? Find out more in this talk. Also covered is a deep-dive into what feature differences exist between MySQL/Percona Server/MariaDB Server. Within 20 minutes, you'll leave informed and knowledgable on what to pick.

A base blog post to get started: https://www.percona.com/blog/2017/11/02/mysql-vs-mariadb-reality-check/

Containers are gaining significant traction as a means of deploying and distributing software in the scientific computing space. With a plethora of solutions to choose from, this talk will go into why there is a tendency for custom container runtimes in this area of computing. We will discuss portability, performance, security and ease of use, as well as direct hardware access as driving factors. As new processor architectures and specialized hardware for machine learning emerge, some of those factors will affect larger parts of the container community.

This talk will give an overview of (some of) the currently available container solutions and how they enable scientists to move their software stacks between machines and work in a reproducible way. The technical challenges and implementations of interfacing with the host system for access to hardware and highly optimized system libraries will be presented. Experiences of running containers on thousands of nodes at NERSC will be shared, which includes the good and the bad parts. The drawbacks of running portable but unoptimized code inside of containers and how that can have a profound impact on the performance of production workloads and what a solution for that could look like, will be addressed. Wrapping up I'd like to show how some of the work done in the scientific space can benefit the broader community and facilitate discussion about that.

We are looking into how RIPE Atlas probes in networks with the majority of end-users for a given country. We measure the path between them and infer if these networks are directly connected or not. With this information we can estimate how centralised the Internet is for a given country (in terms of who has access to user2user IP communication channels) This can be useful information for people who want to develop a more decentralised internet.

(see abstract)

An overview of the DARPA Bay Area SDR Hackfest (darpahackfest.com).

In November of 2017, the United States Defense Advanced Research Projects Agency (DARPA) held its first large-scale Hackfest. The DARPA Bay Area SDR Hackfest focused on using software defined radio (SDR) to control unmanned aerial vehicles (UAV), otherwise known as drones. The week-long Hackfest involved a set of Missions that were tackled by eight teams selected earlier in the year, a series of speakers to give two talks per day, and an open Hacker Space to allow anyone who wanted room to hack, explore, and work on projects.

DARPA created this event to explore a number of questions. First, who else is working in the field of SDR and UAVs that might be able to contribute to the DARPA mission? What new ideas and innovations might prove significant to the future of SDR and UAV technology in the future? And how does free and open source software (FOSS) enable talented engineers and scientists to answer hard technical challenges quickly? The event produced interesting results, and in this talk, we will examine what came out of the Hackfest and think about the future purposes of these kinds of events and ways of engaging the developer communities.

In the SUSE documentation team, we have been using DocBook XML for years. But then, even with all our experience and the strictness of XML, we still make mistakes. So we have been adding QA tools to our tool belt which we are presenting in this talk:

• The SUSE Documentation Style Checker which we use to check for consistent terminology, writing style, correct spelling, "soft" XML rules that don't fit the DTD, and gotchas
• Travis, the CI tool which you probably know and hopefully love and which we use to make sure our documentation validates when it enters our Git repo
• dapscompare which we use during the development of our layout stylesheets to check for unintended consequences and for issues with tool dependencies

Using these tools helps us ensure good formal quality, so that human reviewers can focus on the content. It also helps with make translation efficient.