ANN: linux.conf.au at dash Mon January 21, 10:40p

linux.conf.au
=========================
When: 10:40 AM Monday January 21, 2019
Where: dash

http://lca2019.linux.org.au

Topics
------
1. Morning Workshop
Jonathan Oxer

Refer to http://www.openhardwareconf.org/wiki/OHMC2019

For more info go to http://www.openhardwareconf.org/

2. Toolmaking
Julien Goodwin

From simple shell pipelines through more advanced query & workflow systems basic toolmaking is one of the most valuable ways to increase the efficiency of operations work.

In this presentation we look at toolmaking in other fields, and how to best scale toolmaking work to keep the efficiency wins going.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Toolmaking.mp4
3. Chaining some blocks together
Josh Deprez

I'm a developer who likes writing programs using text (e.g. Python, Go, InterCAL). But I also like to draw diagrams. Let's combine the two approaches with a development environment I've been working on in my spare time for the last couple of years.

Connect up some blocks, write a bit of code, huzzah! A program!

Note: This talk will have nothing whatsoever to do with blockchain technology.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/Writing_Accessible_Code.mp4
4. Python++ – Bringing your code to the next level
Jan Groth

Python is a great language for DevOps tasks. It’s easy to use for automation and offers an end-to-end range of tooling for managing infrastructure on-premise and in the cloud. Scripts are quickly implemented and new features easily rolled out. But what if complexity grows and all of the sudden you find yourself in a complete mess? How do you add a new feature or fix a bug in a script that you struggle to understand because it was written months ago? And do you sometimes see someone else’s code that you like but can't always put your finger on the magic ingredient? This talk is aimed at you if you are reasonably confident reading Python code and want to discover and improve beyond the basics. I'll provide you with ideas and suggestions that will help you stay on top of your coding and will bring it to the next level: Clean code which is easier to understand, more functional, testable and beautiful.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Python_Bringing_your_code_to_the_next_level.mp4
5. The Value of an Apology
Jen Zajac

An exploration of the effects on the open source community of Linus Torvald's 2018 apology about his behaviour within the Linux kernel community. Examining his apology and the reaction to it in detail, with a look at the Code of Conduct changes that resulted and why all of this matters even if you're not a kernel dev.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/The_Value_of_an_Apology.mp4
6. Adventures in highish availability
Peter Chubb

I manage a small farm of servers and network for continuous integration and development, supporting around 50 users. We recently retired about a dozen servers, and have instead used containers and virtual machines on a pair of really big servers.
Given some excess capacity in the new machines, I decided to try to set up replication and failover, so I can bring one machine down for maintenance, and people won't notice (much). Although there are off-the-shelf tools (like Pacemaker), they didn't seem applicable --- so we rolled out own.
In hindsight this may have been a mistake.
In this talk, I'll be talking about all the things that went wrong.

7. What the dep is going on with Go dependency management?
Adam Harvey

Robust dependency management in Go has been a long time coming. The zeroth generation were third party tools like Glide and Godep that attempted to provide some level of order to your $GOPATH, but had no inclination towards being standard tools. These were then followed by dep, which aimed to be a standard tool in the same way that NPM is/was the standard for JavaScript, Composer is for PHP, and Gem is for Ruby.

In 2019, though, there's a new kid in town, and it's now integrated into the standard toolchain: go mod, formerly known as vgo. In this talk I'll introduce go mod using examples of how it can be used with both greenfield projects and old projects that used those earlier tools, both in terms of projects that are simple downstream users of third party modules and those that are intended to be used by others.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/What_the_dep_is_going_on_with_Go_dependency_management.mp4
8. Survival guide for women in IT
Anna Fiofilova

Working in the IT industry today is hard, but it is even harder if you are a woman. There is still lots of “old school thinking" that women face daily. This talk is a survival guide based on real-life stories and different challenges from women of different ages, cultural backgrounds and roles in the Australian IT industry.
Like any survival guide, this one provides you with the essential information to help you identify and overcome the most frequently encountered hazards. Each chapter contains useful tips, instructions and practical advice on a particular issue so you can implement the skills and techniques even under the most stressful circumstances. From the hiring process to promotions and corporate events, you'll have the tools to survive.

You will learn these skills and more:
* Assess your situation and prioritize your needs;
* Surviving techniques for the hiring process;
* Assemble your own custom emergency kit with essentials tools;
* Manage extreme work conditions and overtime;
* Survive corporate parties and drinks;
* Build trust network and create allies;
* Identify your enemies and their habits.
Preparation is the key. If you are starting your career in IT or navigating through it - this guide is for you.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Survival_guide_for_women_in_IT.mp4
9. Chaining some blocks together
Josh Deprez

Connect up some blocks, write a bit of code, huzzah! A program!

Note: This talk will have nothing whatsoever to do with blockchain technology.

10. The Free Software Mirror Group
Brad Cowie, James Forman

A lot of the newer free software projects use either cloud providers or a small set of mirrors located in Europe or the USA to provide access to their software and packages. New Zealand has a unique situation where we have ubiquitous access to fast fibre in urban centres and high latency low bandwidth to International destinations. In order to improve access to popular and new free software projects a number of local sysadmins from different companies formed “The Free Software Mirror Group” (FSMG).

We will take this opportunity to introduce the community to FSMG and propose the ways we want to help the community in future. This talk will cover what happened in FSMG’s first year of operation, from how we started the project to how we operate the project day to day.

FSMG are currently official mirrors in New Zealand for Debian, Kali, Raspbian, CentOS, Arch Linux, OpenBSD and other projects.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/The_Free_Software_Mirror_Group.mp4
11. Donkey Car electronics design
Jonathan Oxer

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/donkey_car_electronics_design_jonathan_oxer.webm
12. The Joy of Spreadsheets
Josh Simmons

Spreadsheets are peak civilization, and those who disagree will be turning in their cloud-based microservice blockchain of functional things by the end of this talk. Spreadsheets have a UI that most people are familiar with, come batteries included, and holy COUNTIF, have you heard about macros?

Join Josh for a joyride down the boulevard of boring technology and explore examples of the genuinely useful and sometimes ridiculous things you can do with spreadsheets.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/The_Joy_of_Spreadsheets.mp4
13. Afternoon Session I
Jonathan Oxer

Refer to http://www.openhardwareconf.org/wiki/OHMC2019

For more info go to http://www.openhardwareconf.org/

14. Distributed storage is easier now: usability from Ceph Luminous to Nautilus
Tim Serong

Distributed storage is *still* complicated, but the Ceph project has put significant effort into making life easier for administrators and users over the past year.

Following on from Sage Weil's LCA 2018 presentation "Making distributed storage easy: usability in Ceph Luminous and beyond", this talk covers the changes we have made in the meantime, including major enhancements to the in-tree Ceph dashboard, centralised configuration management, placement group merging, and the beginnings of a new orchestrator module to tie in with Kubernetes, Salt and Ansible.

The Ceph Mimic release in June 2018 includes much of the above work, but we still have plenty more to do for the upcoming Ceph Nautilus release and beyond.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Distributed_storage_is_easier_now_usability_from_Ceph_Luminous_to_Nautilus.mp4
15. How Much Do You Trust That Package? Understanding The Software Supply Chain
Benno Rice

Did you hear the one where someone gave the maintainership of an npm module to some rando who stuck a cryptocurrency miner in it? Hilarious, right! Well did you also hear the one where someone uploaded malicious packages to PyPI with similar names to popular packages?

Supply chain security is a huge issue in modern software development, and not just for node.js developers. The prevalence of third-party modules, the lack of maintainer time and compensation, and the speed at which we try to develop means that there are many ways that the software supply chain can cause you headaches.

This talk will discuss the history of the software supply chain, the issues that have cropped up in it and why, and discuss some ways to deal with the risks these create.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/How_Much_Do_You_Trust_That_Package_Understanding_The_Software_Supply_Chain.mp4
16. Car connection and config
TBA

(Needs description.)

17. Using containers for HPC workloads (but avoiding Docker)
Eric Burgueño

Containers are the old hot thing. But their adoption in all realms of IT is far from widespread. Most containers we see in the wild today are created to host daemon-type processes and scale them massively, but traditional HPC workloads are different and so HPC shops continue to have some aversion to them.

In this short talk I will discuss some of the challenges that Docker introduces when it comes to using containers in a multi-tenant HPC cluster, and what are some of the possible solutions. We will also explore the relationship between containers and reproducibility in Computational Science.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Using_containers_for_HPC_workloads_but_avoiding_Docker.mp4
18. Donkey Car tuning and training
Andy Gelme

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/donkey_car_tuning_and_training_andy_gelme.webm
19. Automated firewall testing
Kristof Provost

We're all convinced that automated tests are a good idea. For some applications (e.g. grep, awk, cc, ...) this is very straightforward. Others are a lot harder to test, for example firewalls.
Typically testing firewalls takes two to three hosts. One to send traffic, the firewall test host and one to receive traffic. This makes automated test orchestration complex and brittle. This in turn means that tests either don't get written, are difficult to write and/or suffer random failures unrelated to issues in the firewall itself. Virtualisation has made this all somewhat easier, but it's still fiddly and difficult to make robust. It's also slow.

The new FreeBSD network stack virtualisation lets us build on the existing jails system to build test setups, execute tests and clean up in mere seconds, without any requirement for additional hardware, or even hardware virtualisation support.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/Automated_firewall_testing.mp4
20. Samba for the 100,000 user enterprise: are we there yet?
Andrew Bartlett

For a number of years Andrew Bartlett has given presentations along the lines of 'the road to 100k users', and this so in part, this is another update on that long road.

But it is also a milestone, because in the past year Samba has successfully added 124,000 users to the DB in a 4-hour benchmark, re-targeted to LMDB and successfully stood up a second replicated domain controller at the 100,000 user scale.

Beyond scale, Andrew Bartlett will also update the audience on the many other new features coming up in Samba 4.10.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Samba_for_the_100000_user_enterprise_are_we_there_yet.mp4
21. Dirty Samba hacks to make your life easier
Kirin van der Veer

Thanks to the proliferation of IoT devices Samba is everywhere.
But what if you want to use it the "normal" way? You know, as a DC and file server for a large number of users?
What happens when you need to parse the directory for a list of disabled users and take action? Or have regular helpdesk guys deal with locked files?
For regularly running scripts what returns queries faster; pdbedit or ldapsearch?
Perhaps you'd like to setup a linux based hotdesk that will automatically RDP into whatever workstation a user happens to be logged into elsewhere on campus. How to you remotely (and securely) request that information from Samba?
How about a website that acts as a password reset portal? (don't forget your input validation!)
During this talk I will outline and demo a number of scripts and hacks used to make Samba work for our organization (including links to source code).

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Dirty_Samba_hacks_to_make_your_life_easier.mp4
22. Donkey Cars in education
Matt Pattison

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/donkey_cars_education_matt_pattison.webm
23. Clockwork: Programming with rules
Mike O'Connor

Clockwork is a language to describe how machines should behave. It was developed specifically to reduce the risk and cost of custom programming of short-run machines without loss of flexibility. Over several decades we have built custom machines and have built control systems using a variety of technologies, including: Z80 controller boards, C++ control software under Linux and a variety of PLC's. These technologies have had their strengths and weaknesses but overall we have found that Clockwork and its associated tools has far greater re-usability and lower per-machine development overhead than anything else we have tried. The language itself is not like other programming languages and this talk is about how we program in Clockwork.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Monday/Clockwork_Programming_with_rules.mp4
24. Clockwork
Mike O'Connor

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/clockwork_mike_oconnor.webm
25. Afternoon Session II
Jonathan Oxer

Refer to http://www.openhardwareconf.org/wiki/OHMC2019

For more info go to http://www.openhardwareconf.org/

26. Keeping the Balance: loadbalancing demystified
Murali Suriar

Can you explain the entire path that an IP packet takes from your users to your binary? What about a web request? Do you understand the tradeoffs that different kinds of load balancing techniques make? If not, this talk is for you.

Load balancing is hard, and it is made up of many disparate technologies. It cuts across network, transport and application layers. We'll describe different flavours of load balancing (network, naming, application) and how they work.

We will then discuss example use cases, and which load balancing approaches are most appropriate in each case. We'll also relate these to several design patterns for high-availability services that have developed over the years. Finally, we'll relate the techniques we've been discussing to well-known open source technologies and to the major cloud load balancing services.

You will come away with:
- An understanding of various load balancing techniques, and some of their high points and pitfalls.
- Some criteria by which to evaluate different load balancing technologies.
- A framework of heuristics to use when deciding what load balancing pattern(s) to use with your service.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Keeping_the_Balance_loadbalancing_demystified.mp4
27. 10 years of Open Hardware Miniconf projects
Marc Merlin

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/10_years_open_hardware_miniconf_projects_marc_merlin.webm
28. Oracle Public Cloud DevOps: OpenStack CI/CD Infrastructure
Dong Ma

Oracle Public Cloud DevOps development uses a Continuous
Integration/Continuous Deployment (CI/CD) workflow for OpenStack
development. This talk will provide an overview of the Oracle Public
Cloud CI/CD workflow and tools used in our DevOps practice, and our
experiences with these tools.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Oracle_Public_Cloud_DevOps_OpenStack_CICD_Infrastructure.mp4
29. LED Matrix Fun
Marc Merlin

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/led_matrix_fun.webm
30. Lighting Talks C3 Monday
Various

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Monday/lighting_talks.webm
31. Prometheus - For both big and little people
Simon Lyall

Prometheus is a monitoring and alerting system that has gained wide popularity in the last few years. It is especially popular on cloud and kubernetes clusters.

This talk will running the software in both small (a few machines) and larger sites covering both similarities and differences between them.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Prometheus_For_both_big_and_little_people.mp4
32. Creating Ubuntu and Debian container base images, the old and simple way
Hamish Coleman

Containers are everywhere, but do you know how to create the root filesystems that they use? There are simple tools available to create your own custom Ubuntu or Debian root filesystem. By using these tools to build environments matching your needs, you will end up with a better understanding of how containers are built - and how to debug them - as well as gain access to more options that can speed up your own builds and testing.

In this presentation, I will show the debootstrap and multistrap tools and provide worked examples on how to avoid their gotchas and end up with a bootable root filesystem.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Monday/Creating_Ubuntu_and_Debian_container_base_images_the_old_and_simple_way.mp4
33. Keynote: Beyond README.md (Room C1)
Rory Aronson

We all understand the importance of the README.md file in open-source software. But what happens when you go beyond software and begin to document your hardware and your business model too? What could happen if you transformed your documentation from a file, to a product? In this talk, Rory Aronson tells the story of how FarmBot Inc is raising the bar of what it means to have great documentation, and why it is vital to his mission and vision.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Keynote_Beyond_READMEmd_Room_C1.mp4
34. Keynote: Beyond README.md (C1)
Rory Aronson

35. Keynote: Beyond README.md (C1)
Rory Aronson

36. Keynote: Beyond README.md (C1)
Rory Aronson

37. Keynote: Beyond README.md (C1)
Rory Aronson

38. Being kind to 3am you
Katie McLaughlin

For engineers who participate in on-call rotations, documentation is critical to resolving issues. Especially when, at 3am, the responding engineer will be -- initially -- on their own, and not performing at their peak.

In this short presentation, Katie will discuss some strategies she's implemented as a veteran on-call Site Reliability Engineer, and shows you how to be kind to 3am you.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Being_kind_to_3am_you.mp4
39. Reliable Linux Kernel Crash Dump with Micro-Controller Assistance
Vasant Hegde

Kdump is the standard mechanism to generate Linux kernel crash dumps. Reliability of kdump has always been a concern as it suffers from many possible failure modes -- rogue DMA, bad device state at the time of crash, dump capture kernel corruption, etc. Kdump, therefore, works on a best effort basis.

The IBM POWER9 processor has a number of satellite processors called PowerPC Processing Elements (PPEs) -- micro-controllers based on a scaled down version of embedded PowerPC processor. PPEs perform various boot and run-time activities for the normal working of the system. One of these PPEs is the Self-Boot Engine (SBE) which plays a significant part in the early boot of the Power processor.

In this presentation, we detail the concept, design, implementation and learning, from a framework that allows for guaranteed capture of the memory state of both the crashed Linux kernel and the OPAL firmware it runs on. On receipt of an indication that the OS/Firmware has crashed, the SBE triggers a memory preserving boot. It then passes control to the early boot firmware which then captures both the OPAL firmware and Linux kernel crash dumps. OPAL firmware then works in conjunction with Linux to extract this dump. Linux then formats the dumps appropriately so that existing analysis tools (crash/gdb) can be used on them. All the components involved to produce the dumps are Open Source.

We present various scenarios of software failure and how this framework is designed to work in all such cases, making this solution more robust than the standard kdump.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Reliable_Linux_Kernel_Crash_Dump_with_MicroController_Assistance.mp4
40. Reproducing Colour: Understanding our Cameras
William Brown

Colour and Colour reproduction has been a detailed element of photography since the beginning of the art. From how we represent colours in black and white to create soft tones, vivid colours of landscapes, to the accurate reproductions for analysis.

Modern digital cameras have a detailed and extensive assortment of colour tools internally. From correcting for lens defects and distortions, to compensating for sensor design, there is a huge amount of stored knowledge in the camera bodies we own. How can we access and understand these? How is this knowledge built? And how can we manipulate and improve colour in our open source tools for photography?

William will explore the history of colour in photography, detail how cameras reproduce colours, and demonstrate ideas, tools and techniques for colour effects in the open source photo editor darktable - a non-destructive and extensive professional photo editing tool for photographers.

41. Design for Security
Serena Chen

Today, the internet owns our lives. Every website and app we touch knows us: our personal information, our inane ramblings, our deepest secrets. Security has never been more crucial, yet it’s a rare topic outside of ISM teams and hackers. And through the design lens, it’s completely missing.

This is a mistake.

There’s a misconception that security is a niche for masterminds. In the real world, most security breaches don’t come from 0days or neat hacks. In fact, most errors are human—simple scams that have worked since society began.

This is where design fills a missed opportunity.

Good user experience design is necessary for good security. We can craft paths of least resistance that match paths of most security. We can educate our users on what is good practice and what is security theater. We can build secure flows that are usable, not obstructive or annoying.

In this talk we'll go over four strategies that apply design thinking to security problems. We'll pinpoint which practices work and which are detrimental. And finally, we'll walk through how you can use design thinking to approach security issues in your websites, apps, and companies in a whole new way.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/Design_for_Security.mp4
42. The world has changed, but school hasn't
Lana Brindley, Tahlia White

The world has moved on significantly from the Victorian era, when 'school' as we now know it was first invented. And while the funding models and teaching methods have changed somewhat over the past couple of hundred years, what children do in school has, in reality, changed very little.

Lana will take you through a brief history of public schooling in Australia, focussing on the relative openness of each major step along the way, while Tahlia will recount stories of her own experiences as a student in the present-day public school system.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/The_world_has_changed_but_school_hasnt.mp4
43. Database as Filesystem
Peter Chubb

Most network file systems are either a layer over an existing filesystem (NFS, CIFS), or are develped from scratch to have separate, replicated, purpose-designed databases for metadata and object store (GFS, Glusterfs). At the same time, most database engines provide (or can be coerced into providing) replication and all the ACID properties needed for a high-performance filesystem.

Idea: Use a database engine (Postgres, MariaDB) on raw partitions with a fast separate nVME log file; build POSIX file system semantics on top. It's pretty obvious that this could work; I'm just starting to implement it so performance and durability can be measured.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Database_as_Filesystem.webm
44. Making Yourself Redundant on Day One
Alexandra Perkins

The first few weeks at a new job are hard. There seem to be too many questions and not enough answers, and so much assumed knowledge about the company you joined and the products they make.

I’m going to talk about how you can make those first few weeks your most productive and valuable to your new company. By writing internal documentation that answers all the questions only someone new on the block knows to ask, you can help pave the way for new hires in the future, and even help identify and solve customer pain points.

Drawing from my own experiences working as an intern and support agent among highly technical teams, I will go over deciding what to document based on the level of technical proficiency you would expect the reader to have, how to use tone to convey the company’s spirit and keep a future reader interested, and how to future-proof your internal documentation so it doesn’t stop being updated when you move on.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Making_Yourself_Redundant_on_Day_One.mp4
45. Noisefloor: Are web technologies ready for real time audio?
Jacob Lister

Javascript JITs have come a long way in recent years, now offering near native code performance on the fly for many application types.

With the recent adoption on AudioWorklets, the browser is now becoming a viable platform for real time audio processing.

Jacob will be presenting Noisefloor, a proof of concept software Module Synthesizer implemented in Golang and transpiled to Javascript,
and discussing some of the challenges involved in managing a reliable real time audio thread alongside a browser based UI.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Tuesday/Noisefloor_Are_web_technologies_ready_for_real_time_audio.mp4
46. Stepping up the game against Web trackers
Martin Krafft

The attempt to standardize the Do-Not-Track HTTP request header is going nowhere, and it's cute anyway, in that it expects the other
side to honour the request, and how would we know if they did? After all, tracking is serious business, and it's hard to imagine a company in this field walking past money lying on the street without picking it up.

Martin is at war with what the Web has become, and he's here to talk to you about techniques he's using to minimise his browsing
footprint on a day to day basis. Do not attend if you'd prefer to think of the Web as the decentralized knowledge-sharing network it was originally conceived as.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/Stepping_up_the_game_against_Web_trackers.mp4
47. Kernel Security Is Cool Again
Casey Schaufler

Why is Linux kernel security getting so much attention all of a sudden, and where is it going? What is the Linux Hardening Project about? What are the Landlock, SARA and WhiteEgret security modules for? This can't be all about side channel attacks, can it? Is security a good place to contribute? Casey Schaufler, who has been working in kernels and security for a very long time, will talk about the current state of Linux kernel security development. The efforts to make the kernel less susceptible to attack will be outlined. New developments in access controls will be described. Infrastructure changes, including expanded security module stacking, will be covered. You'll hear about integrity, TPMs, trusted boot and more. The talk will wrap up with predictions and some areas that aren't getting the attention they may deserve.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Kernel_Security_Is_Cool_Again.mp4
48. Open CS education resources for schools - how hard could it be?
Tim Bell

Computational Thinking and related topics are appearing in school curricula around the world. There are many barriers to adoption, and one significant one is supporting teachers to find relevant and easy-to-deploy teaching material. This talk will describe experiences with two on-line open resources that have been developed at the University of Canterbury: CS Unplugged, and the CS Field Guide. We will look at principles used to design the resources, and challenges included making it relevant for different cultures, curricula and languages.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/Open_CS_education_resources_for_schools_how_hard_could_it_be.mp4
49. JIT Learning: It's great until it isn't
Tessa Bradbury

Just-in-time learning, the act of learning when you need it rather than spending weeks/months/years on it up front, is part and parcel of modern software development. It's how we make it though the ever-changing industry we're in and how we make use of all the abstraction layers we have. But does it really work for everything?

Drawing on specific stories from my first few years as a software developer, we'll explore some of the underlying assumptions of JIT learning, some notable instances where it falls apart and some ways of addressing those issues.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/JIT_Learning_Its_great_until_it_isnt.mp4
50. Printed circuit artboards - how rapid PCB manufacturing is a thing of beauty
Christopher Biggs

For Christmas 2018 I made an IoT-enabled LED star for our Christmas tree.
I designed it in an afternoon and had the circuit boards in my hands 5 days later, for a cost of $5.00 for ten.

Learn how to get the most out of PCB design tools and PCB manufacture services to let your electronic circuits become a feature of your art.

A circuit board doesn't have to be green, and it doesn't have to be rectangular. You can make your circuit part of your art by varying
* the shape of the board itself, or
* including artistic elements in the silk-screen overlay, or even
* make your copper tracks an artwork of their own

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Tuesday/Printed_circuit_artboards_how_rapid_PCB_manufacturing_is_a_thing_of_beauty.mp4
51. Petabytes Data Migration and Load Balancing with Football+MARS
Thomas Schoebel-Theuer

MARS is used at 1&1 IONOS for hardware lifecycle and load balancing of a few thousands of stateful LXC containers, in addition to its traditional long-distance data replication capabilities through network bottlenecks.

The talk explains some background, the Football toolset, and discusses experiences gained from a major migration project to newer hardware, increasing density, thus saving power costs of some millions of € per year, while improving customer performance.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/Petabytes_Data_Migration_and_Load_Balancing_with_FootballMARS.webm
52. The delightful user experience of security
Casey Schaufler

The delightful user experience of security – We all know that computer security is obtrusive, annoying and expensive. At every layer of software from wifi modem micro-code to web backgammon there are passwords, updates and restrictions that get in the way of doing the simple things we set out to accomplish. If you’re a developer, it’s even worse with CVE tracking, code scanners and named exploits sucking away precious schedule time. But what if it wasn’t that way? What would software be like if someone developed computer security with the explicit goal of creating something people will like? Casey Schaufler knows how dreadful the experience of security can be, having implemented everything from access control lists and release process to the ugliest login screen ever produced. In this talk he steps back from the traditional approach to computer security and investigates it from the viewpoint of providing a delightful user experience. The talk starts off with the basic premises of security and why they ought to make systems more usable, not less. It continues with the importance of creating security models that reflect what people want the software to do, and how to go about doing so. The process of building software to enforce those models and the mechanism for ensuring that both security and user experience are maintained throughout are described. Finally, the problem of keeping the user experience from deteriorating when faced with new and unexpected security challenges is addressed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/The_delightful_user_experience_of_security.mp4
53. Clang Built Linux
Joel Stanley

Clang Built Linux is a collection of efforts to get the upstream kernel building with Clang. It has resulted it patches to the build system, kernel code, and llvm/clang it self.

This talk will demonstrate how to build a kernel with clang, and highlight the remaining work to be done.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Clang_Built_Linux.mp4
54. Finding your tribe - choosing open source communities
Cintia Del Rio

You've fallen in love with open source and now you want to volunteer some of your time for a nice project! You've read several guides on how to raise good tickets, how to make good questions, and you feel ready to learn more. But when you attempt to dip your toe in the water and create a pull request, you are bitten but some rather nasty comments which make you question your ability to code. Or maybe you never tried to join a community because you've seen how aggressive they can be. You've heard about bullying and harassment that can happen. In this talk, I'm going to talk about tips and tricks on how to find an open source project that's worth your time and doesn't cost your mental health.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Finding_your_tribe_choosing_open_source_communities.mp4
55. The case for learning real programming skills
Arjen Lentz

HTML is not a programming language.
Being sandboxed in an app on a tablet is not programming.
If we can agree that these things are not good, we need to look at why these things are happening.

Of course the issue is not about programming as such, it's really all about thinking, patterns, and problem solving!
And not getting that right is obviously very detrimental to our children's and country's future. We must do better.

What have other countries been doing? There are some surprising insights there.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/The_case_for_learning_real_programming_skills.mp4
56. MIXED REALITY AND ART: THE QUEST FOR THE SHINY
J Rosenbaum

Augmented Reality and Virtual Reality are this year’s hottest buzzwords when it comes to art. Are they just gimmicks or is there something deeper behind the work? When artists can create whole immersive worlds or blur the line between the digital and the real what we have to say is still of the most importance. This talk is about the latest technologies and how to stay on track and not get (too) distracted by the shiny new other options out there! J Rosenbaum is a digital artist working in 3D Modeling and Augmented Reality with Machine Learning based interactions. Join us as they unpack what new technology brings to art and what artists bring to new technologies.

⚠️ Content warning: This talk contains images of artistic nudity

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Tuesday/MIXED_REALITY_AND_ART_THE_QUEST_FOR_THE_SHINY.mp4
57. Forwarding syscalls to userspace
Tycho Andersen

Containers are ever popular, and are increasingly presented as an alternative to virtual machines. However, there are some obvious gaps in the API available to containers vs. what's available to root on the host. For example, containers cannot safely load kernel modules, or mount arbitrary filesystems.
In this talk, Tycho will present a kernel patchset in development for passing syscalls off to a userspace handler, which can perform actions on behalf of the task that performed the syscall. For example, if a container tries to load a kernel module, the userspace daemon might check that the module is in a whitelist, and load the host's version of the module instead. The container is safely allowed to load kernel modules, whereas before it was not.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Forwarding_syscalls_to_userspace.mp4
58. Zen and the Art of Learning Assembler in the 21st Century
Tom Cully

A presentation on the benefits of learning (and starting students at) Assembler from experience with the BlackRaven Dojo - i.e. once you have coded in assembly, 'There's No Magic'. In today's world of 'learn to code in 6 weeks' courses and programmes that teach high-level languages in the first month, we are in danger of the widening gap between an abstract and fundamental understanding of machines. I put forward the case that we should start training young engineers at the lowest possible level (assembly language) - not because it is necessarily useful of itself, but because of the deep understanding and efficiency learned from such a low level approach. There is a saying in Wing Tsun Kung Fu - 'If you can't do it slow, you can't do it fast.' - I propose that something similar is true in software; if one does not develop a deep understanding of the fundamentals of machine architecture and programming at the chip level, one is less likely to be able to meet the challenges of the modern age; that learning the lowest level possible teaches lessons that are relevant even when the target architecture has multiple cores, GHz of performance, and Gbs of memory. With our recent focus on IoT, an 'old-skool' approach is especially relevant given IoT and embedded devices, which possess very limited capabilities by comparison.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/Zen_and_the_Art_of_Learning_Assembler_in_the_21st_Century.mp4
59. Through the looking glass - how user testing can give technical writers better perspective
Fraser Mitchell

Technical writing and user testing may seem like two compltetly different fields, but they actually intersect more often than not. If you think about it, they both share the same purpose of ensuring that the UX is smooth and streamlined.

When in the position of writing documentation, we are always told about the issues that users face on a daily basis. But what if we tumbled down the rabbithole and into the world of user testing, and actually witnessed the users issue first hand?

In this talk I want to discuss the many benefits of intersecting user testing with technical documentation. I will share my experiences of writing documnetation and conducting user testing, while also going over several skills and techniques that can be used to convert the results from user testing into better documentation.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Through_the_looking_glass_how_user_testing_can_give_technical_writers_better_perspective.mp4
60. Stories as Systems: How emerging narrative tools are shaping the future of storytelling
Mark Rickerby

Although storytelling across cultures has reused common structural elements for thousands of years, this extraordinary consistency has defied explanation. There is no unified theory of narrative that can fully explain the rich complexity and affect of the stories we love.

To augment and extend our powers of generative storytelling using computers, such a theory—if it existed—would be extremely helpful! Whether our goal is to create experimental dramatic fiction or to develop game systems that dynamically respond and adapt to player input and simulation events, somehow we need to encode knowledge of narrative structures in a form that can be manipulated by our tools and algorithms.

In this talk, we’ll take a whirlwind tour through different computational models for representing narrative structure and how they’ve been put into practice in emerging open source tools.

Is it possible to create systems that balance the strict causal logic of plots and conflict models with the dreamlike free-association found in fairytales and modernist fiction? To answer this question, we’ll compare and contrast ideas from the cutting-edge of narrative AI research with the creative practices of contemporary novelists who approach story structure in surprising and innovative ways.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Tuesday/Stories_as_Systems_How_emerging_narrative_tools_are_shaping_the_future_of_storytelling.mp4
61. MM101 introduction to memory management
Christopher Lameter

An introduction to Linux memory management at the levels of the basic mechanisms. The basics of paging. Understanding hardware memory management and the difference between virtual, physical and swap memory. How do determine the hardware installed and how to figure out the use of that memory by processes. How a process uses physical and virtual memory effectively. How to control overcommit and virtual and/or physical memory limits.

Also includes an introduction to the basic knobs in Linux to control memory management and system calls so that a process can control its memory usage.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/MM101_introduction_to_memory_management.mp4
62. My year on the front line - cleaning infected sites
Stephen Rees-Carter

Stephen joined the Wordfence Site Cleaning team part-time at the start of 2017, having virtually no experience with WordPress, Wordfence, or cleaning infected websites. His only real credentials were a love of PHP development, a keen interest in security, and the crazy idea that cleaning infected sites would be fun. Fast-forward to the end of 2018, Stephen has stepped back from site cleaning and has joined the Wordfence team full time as a developer, so now it's time for him to tell his story. In this talk he will share stories from the more memorable sites he cleaned (names changed to protect the innocent), including revealing his all-time favorite WP malware, and the epic tale of the persistent attacker that almost thwarted the Wordfence team completely. Scattered throughout will be tips and ideas to help protect your site from compromise and keep everyone (except the bad guys!) happy.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/My_year_on_the_front_line_cleaning_infected_sites.mp4
63. Expanding the Soft Skills Toolkit: The Art and Science of Diagramming
Adam Moszt

You’ve put in the hard yards to plan your project, and now it’s time to get buy-in from the stakeholders. You’ve set up the meetings, you’re planning your presentation. Oh, no! The process diagram looks like a bowl of spaghetti, and that flowchart has more loops than a chainmail shirt. How are the meeting attendees going to understand this?

Never fear! Once you understand the principles of good diagramming, you will be a master of supplying the right image, first time, every time! People far (like the back of the meeting room) and wide (like the person all the way in the corner over there) will understand your intent at the merest glance.

You’ll learn how to make effective diagram that stick in the mind of your audience. In doing so, you’ll be able to present information quickly and comprehensibly to people, and be able to explain even the most complex of processes with clarity and ease. The principles that you learn here will also translate well into UI design and many other facets of user-facing application development and communication.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Expanding_the_Soft_Skills_Toolkit.mp4
64. Open Source AI and speech recognition
Kathy Reid

This session will present a history of open source voice projects and provide an overview of the current open source voice landscape. From Star Trek’s computer, to Knight Rider’s K.I.T.T, to Selma in Time Trax, we have long desired to work with computers using the power of our voice. But while attractive, this technology is currently used to gather data, using spoken utterances to personalize advertisements, and provide privacy-impugning ‘nudges. Enter open source, privacy-focussed voice assistants. As voice becomes ubiquitous, those organisations wanting to ensure privacy and prevent vendor lock-in are turning to open source solutions.What's out there? What are the differences? And what sort of things should you consider when you're choosing an open source voice platform? What does the open source voice assistant roadmap look like? What models are there for sustainability and revenue generation in open source voice? This presentation will provide an overview of the voice stack, and the different open source options available at each layer of the stack, as well as their pros and cons, enabling you to make an informed choice about open source voice.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/Open_Source_AI_and_speech_recognition.mp4
65. Patching through the snow: decentralised kernel CI on every patch
Russell Currey

Just like the development of the kernel itself, its testing is all over the
place. There are countless public kernel testing projects and probably even
more private ones, with hardware vendors testing what works on their own
machines and maintainers automating checks for what should go into their trees.
If you're a developer, you probably don't know about any of this unless someone
directly tells you.

The granularity of running these tests is similarly all over the place:
many test environments just look at mainline, many look at linux-next or
trees of specific maintainers, and some run on every patch, like the Intel
0-day bot. If you're a developer, unless your patch doesn't compile, you're
probably not going to hear about it.

Projects that use pull requests on GitHub as a code submission method have it
easy: a developer sends a PR, some CI system magically tests it, and
developers and maintainers alike can quickly see if the code has issues.
The value in continuous integration is about quick feedback to the developer,
and saving precious time of reviewers and maintainers.

This is where snowpatch comes in, using Patchwork as the publicly visible
platform for test results on patches. Tests can come in from anywhere,
even an internal lab of a hardware vendor, and have their results published
for the world to see within minutes of a patch being sent. It's the closest
thing we have in the world of mailing lists to the simplicity of the GitHub
workflow, it's easy to get going, and it can function as decentralised as
the rest of kernel development.

We're going to cover how snowpatch works, why it's useful, what we're doing
with it currently, and look to the future to determine just how much we could
tell the world about a patch, only minutes after it's been sent.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/Patching_through_the_snow_decentralised_kernel_CI_on_every_patch.mp4
66. Democratising higher education with OERs and FOSS
Dave Lane

The Open Education Resource Foundation, based in Dunedin, NZ, exists to make higher education available to everyone in the world at a reasonable cost. We achieve quality by using an open source process to assemble world-class openly-licensed curriculum materials at WikiEducator.org.

We deliver course materials through our OER universitas (https://oeru.org) network, which includes more than 30 institutional partners, using our "next generation digital learning environment" made up entirely of open source online services, situated around the world.

All of our custom development and integration is made available as open source software, and we provide both an open code repository and a "how-to" blog (https://tech.oeru.org) which helps others recreate our services for their own institutions or communities.

My presentation will detail the state of our open source technology stack (it will be built around the content of this blog post: https://tech.oeru.org/2018-update-oeru-technology-stack

The foundation operates on the principle that no learner should have to compromise their freedom to participate in our learning, nor should they have to compromise their digital privacy. To aid that, we use exclusively open source software, and all content is openly available without registration. The only cost to learners is for assessment services for formal academic credit provided by our institutional partners.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/Democratising_higher_education_with_OERs_and_FOSS.mp4
67. How to develop software in an #AABill world
Ben Dechrai

What are the implications, when governments pass legislation that force developers to build insecurities in to their software?

This part-talk-part-discussion is designed to illicit concerns, discuss remedies, and everything in between.

This is a potentially heated subject. Let it warm your cockles.

68. How to avoid meetings
Maia Sauren

Have a call instead of sending email, they said. It's better for communication, they said.

What if everyone hates meetings, and the rooms are perpetually booked, and nobody understands your accent? How do you do that day in, day out with an international team across time zones and languages? How do you keep everyone engaged, make sure work doesn’t get siloed between sites, ensure everyone feels empowered to ask questions? What if one group doesn’t quite speak the common language, or isn’t up to speed on how to push back on work? How about resolving conflict, or translating professional contexts?

This talk is the coalescing of years of experience working with many international teams in multiple countries. It will cover: successful and unsuccessful strategies for pulling together software teams across time and space; embracing the awkward; spotting conflicts before they escalate; translating context and taxonomy; and how to grow participation and collaboration. Most importantly, it will go through how to stealthily work yourself out of a job by teaching everyone else to do it.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/How_to_avoid_meetings.mp4
69. Designing functional clothes with Haskell!
Noon van der Silk

I love wearing colourful clothes with funky patterns, but these are hard to find! Clothes with patterns that have rich and meaningful structure are my favourite. So, I have been learning how to use open-source “diagrams” library (written in Haskell) to make a wide variety of designs which can then be printed on different items of clothing. My inspiration and designs come from patterns I’ve found online or in life - like in tiles or artworks, or from fun mathematical structures.

In this talk, I will discuss how to use the “diagrams” library to create elegant, composable and parameterised graphics. This library is special in that it lets you manipulate drawings in a convenient way that is powerful and flexible. As such, it lets you build sophisticated structures out of simple components which you can reuse and put together in interesting ways. Also, it’s a great excuse to learn Haskell!

Finally, I will show how to build a pipeline that enables open-source fashion design, so that you too can have a closet full of purely functional clothing!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Tuesday/Designing_functional_clothes_with_Haskell.mp4
70. Disaster recovery book
Svetlana Marina

Releasing your software into production can be an exciting time for your team. If everything goes well, you will get inevitable production incidents and support requests from your customers! Congratulations! It is a good sign, your system is being used.
If things go really well, you may find that the velocity of your team is slowing down and maybe you firefighting too much, instead of improving your product and delivering new functionality.

Having a recent experience of establishing operational support model within a development team, I would like to share some guidelines we developed when writing operational runbooks for our product.

In this talk, I will cover industry accepted standards around operational runbooks, why should we write them, when, what should go in there, how detailed do you need to be, how to keep them up to date etc.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/Disaster_recovery_book.mp4
71. Gen-Z on Linux: Supporting a New System Interconnect in Free Software
Keith Packard

System interconnects is a term which spans a wide range of wiring
techniques within computer systems. The term encompasses everything
from memory connections like DDR, processor-to-processor links like
UPI or Infinity Fabric, device connection links like USB or PCIe to
machine-to-machine connections like Infiniband or Ethernet.

Gen-Z is an interconnect which can span this whole range. Gen-Z is
being developed by a broad industry consortium as an open standard and
has reached version 1.0, making it ready for implementation in
hardware and software.

Within Linux, system interconnects support requires infrastructure
that provides device drivers access to low-level interconnect
interface hardware. This infrastructure offers discovery, addressing
and communication abstraction so that device drivers need not
implement direct support for the low-level interconnect hardware
itself. Linux offers as many interconnect abstractions as there are
supported interconnects, from packets for networking through blocks
for storage and URBs for USB. Gen-Z will also require new abstractions
and management methods

Gen-Z provides broad capabilities and uses ideas from a broad range of
existing hardware. Adding Gen-Z support to Linux will require a
similarly broad range of techniques, some adapted from existing
subsystems and some purpose-built.

This presentation will first describe what Gen-Z is and how it works,
describe a freely available Gen-Z emulator and then discuss the
current architecture for Linux support of Gen-Z. Finally, the
simulator will be used to show the current state of the Linux Gen-Z
subsystem development.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/GenZ_on_Linux_Supporting_a_New_System_Interconnect_in_Free_Software.mp4
72. Decentralising identity
Martin Krafft

By now you've probably heard the term "self-sovereign identity", and most likely this was associated with blockchain of one form or another. Let's cut through the hype and look at what decentralising identity, and putting users back in control of their data is really all about. I'll introduce the concept of Decentralized Identifiers (DIDs), and look at what the hard questions are, which by the way, blockchain cannot solve for you.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/Decentralising_identity.mp4
73. Using open source communities to provide uni students an insight into the IT industry.
Peter Serwylo

When preparing students for work, it is important that they are able to see how real teams of people interact in order to learn what a real IT project looks like. This is something that can only happen due to the openness that is inherent in our community. At Monash University, final year undergraduate and masters students are frequently directed to various open source communities to explain high quality examples of both technical and non technical skills. The list is never ending, and includes communicating clearly, documenting requirements, peer reviews, user tests, unit tests, CI/CD, infrastructure management, and many more

In this presentation, we'll walk through some important skills that may not fit easily into a typical university curriculum, but for which many well run open source communities excel at. We will highlight some key insights that students are able to gleam from open source projects that they would be unable to otherwise achieve.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Tuesday/Using_open_source_communities_to_provide_uni_students_an_insight_into_the_IT_industry.mp4
74. The Bus Plan - Junior Staff Training
Andrew Jeffree

Automation is incredibly useful, but is it limiting the ability of our junior staff to actually learn?

In this current age of SaaS/IaaS, the effort required now to set up a blog or a website or do anything these days is minimal - with just the click of a button it's all up and working due to the wonderful power of automation.

What if the button doesn't work?

What if you need to go further, or do something more complex?

People are relying on automation more and more. So how do we educate our staff to be able to deal with it whether that be maintaining, fixing or even replacing?

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/The_Bus_Plan_Junior_Staff_Training_2.mp4
75. XArray: One Data Structure To Rule Them All
Matthew Wilcox

The XArray has been merged for Linux 4.21. Initially conceived as a replacement for the Radix Tree, it should also be used as a replacement for the IDR and can be used instead of a doubly-linked list in some circumstances.

Future improvements to the XArray may make this the only data structure we need, replacing linked lists under all circumstances, the rbtree and even hash tables.

Come to this talk and learn how to use the XArray now and how to use it in the future.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Tuesday/XArray_One_Data_Structure_To_Rule_Them_All.mp4
76. How to Disappear Completely
Lilly Ryan

If you’ve ever wanted an invisibility cloak, this talk is for you.

Cameras peer at us from street corners, from phones, from the dashes of passing cars, and from shopping mall advertisements. Even when you’re not posing for a selfie, you might end up in the background of someone else’s picture while you’re out at dinner — and if that photograph is uploaded to a social media site, facial recognition can pick you out of the lineup.

Machines are getting better at recognising our faces — but if you want to sneak through the streets of your city like a young wizard in the corridors after midnight, there is still hope.

This talk provides an overview of the latest urban camouflage technology and how to deploy it in order to foil facial recognition. During this session you’ll learn the ways machines “see” us, and how to play with them in order to become invisible. We’ll dive into the ethics of biometric identification, the way current legislation affects this technology, and what is needed for facial recognition technology to be both useful and just.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Tuesday/How_to_Disappear_Completely.mp4
77. When Agile Doesn't Work Anymore: Managing a Large Documentation Project
Lana Brindley

We all age. Some more gracefully than others. Our documentation ages, too, and sadly it's not always glamorous. Docs that start out as a thing of sartorial elegance can, many years and patches later, become tired and sad and badly in need of retirement. Sometimes the content is so out of date and incorrect, the format so anachronistic that it needs to be consigned to a recycling bin. But not all documentation should be euthanised. Sometimes, it just needs a face lift.

Agile documentation is, by its very nature, piecemeal, which can make it difficult to maintain a large documentation suite, and almost impossible to perform a large project that requires meticulous planning and extensive testing. In this talk I'll cover situations that require a complete documentation overhaul, how to go about planning for and undertaking such a project, and (perhaps most importantly) how to sell a Waterfall-style project to your Agile Product Owner.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Tuesday/When_Agile_Doesnt_Work_Anymore_Managing_a_Large_Documentation_Project.mp4
78. Keynote: #WeAreNotWaiting: how open source is changing healthcare (C1)
Dana Lewis

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Keynote_WeAreNotWaiting_how_open_source_is_changing_healthcare_C1.mp4
79. De-mystifying interrupt balancing: irqbalance
PJ (Peter) Waskiewicz

irqbalance is a userspace daemon that has been available for a number of years. Its main purpose is to make decisions on how to best balance interrupts within a system. Getting this "right" can be a challenge, since it needs to run on enterprise-level systems all the way to a mobile device. Taking things like NUMA locality, bus hierarchy, shared interrupts, cache locality, all into consideration, irqbalance is often misunderstood with how it works, what it can do, and what it cannot do.

As co-maintainer of irqbalance, this talk is intended to pull the curtain back on how this whole framework operates. What pieces of the Linux kernel are involved in balancing interrupts, where policies are enforced, current best-known configurations, and future ideas to try and improve operation, are all things targeted with this talk.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/Demystifying_interrupt_balancing_irqbalance.mp4
80. Taking technology to the birds
Clare Mclennan, Menno Finlay-Smits

The Cacophony Project is a small, open-source, non-profit with a gigantic vision. We aim to save New Zealand's native birds which are under threat from introduced predators such as possums, stoats, and rats.

In the last couple of years we have been busy developing digital solutions to monitor native bird populations and eliminate their introduced predators.

These solutions promise to be several magnitudes more effective than traditional approaches that are in use today.

During our talk you will get to see and touch our thermal cameras and the machine learning model that we use to automatically identify animals. We will also talk about our latest developments such as using audio based lures and our software controlled trap replacements.

As part our session we will also be discussing how we make open source for work us, as our project is not your average open source project. This is due to our compelling but expansive vision, the start up phase we are in, and that our work spans software, hardware and science.

Come and see what a handful of people have been able to achieve with the help of our dedicated open source community!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Taking_technology_to_the_birds.mp4
81. Plastic is Forever: Designing Tomu's Injection-Molded Case
Sean "xobs" Cross

Tomu is a small USB computer designed to fit entirely within a USB Type-A slot. But how do you fit a small circuit board in a USB slot without having it fall out? What exactly is the process of designing something to be made out of plastic? What is open source injection molding?

Come and hear what we learned while making the case for Tomu. From reading mechanical diagrams to using open source software to actually getting it manufactured, we'll cover everything you've ever wanted to know about producing simple cases, what it takes to decide if your project should make the jump to plastic, and how to read the tea leaves when looking at injection molded parts.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/Plastic_is_Forever_Designing_Tomus_InjectionMolded_Case.mp4
82. FileSender: Sharing large files across research facilities
Ben Martin

The FileSender project allows large files (100gb+) to easily be shared with people at other companies and research facilities. Uploads and downloads occur in the browser and files can be uploaded to a FileSender hosted at your organization or you can be invited as a guest to another research facility installation. Optional end to end encryption keeps the data secure from users on the server, all crypto is done in the browser keeping it simple and secure for users.

While a raw http and ftp server can be used to share files, many non technical users will not have access to upload and administer one of these servers. Access control to only selected users and automatic expiration of hosted files might be difficult for users more interested in research which is outside the IT field.

FileSender supports push and pull models. To push, if you have access to a FileSender installation you can upload the file to it and inform those who you want to access the data to allow them to obtain it. To pull a file, you can create a guest on your FileSender install and invite a user to upload the data there. Guests can be subjected to specific access control, for example, only uploading a single file, and only to you.

I would love to talk about the challenges the FileSender project tries to address, the php/js code that comprise it, the history, and development of FileSender. I think it is a useful project to know and use in research and commercial environments and would love to hear feedback on where the project might want to move in the future.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/FileSender_Sharing_large_files_across_research_facilities.mp4
83. See what your computer is doing with Ftrace utilities
Steven Rostedt

Ftrace is the official tracer of the Linux kernel. It allows you to see what is happening in the black box that the applications sit on. Ftrace is a very powerful tool, but like all tools, it is useless if you don't know how to use it, or even know its full potential. This tutorial will teach you how to use Ftrace from the command line (all major distributions have Ftrace enabled), as well as how to use trace-cmd and finally, if time allows, the new KernelShark. trace-cmd and KernelShark can be easily downloaded from Steven's git repository on kernel.org (best to get the latest even though your distribution may have an older version available). Steven will first walk you through some of the main commands to display how Ftrace can show you how your applications are being scheduled in, how many page faults they are taking, and even see what other applications may be interfering with your main application. Some of these can be used to see if there's any rouge applications running on your system. Then Steven will walk you through how to use trace-cmd as it allows you to have even more flexibility with its post processing analysis. Finally, an introduction to the new KernelShark, which shows a graphic display of the data that you have retrieved.

In order to get the most from this tutorial, it is recommend that you:
1) Have a laptop running a recent Linux distribution (Running in a VM will work too)
2) Download and install the most recent trace-cmd and KernelShark
$ git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
$ cd trace-cmd
$ make
$ less kernel-shark-qt/README # to make sure you have all the dependencies
$ make gui
$ make doc
$ sudo make install
$ sudo make install_gui
$ sudo make install_doc
3) It will be helpful if you download the source code of the kernel that is running on your laptop
4) Having the debug info of that kernel can also be useful

Note, 3 and 4 above are helpful but not required.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Wednesday/See_what_your_computer_is_doing_with_Ftrace_utilities.mp4
84. Open Source Superhumans
Jonathan Oxer

Learn how Open Source hardware and software can be used in a wide variety of assistive technologies, including wheelchair control, environmental systems, robotics, communication, prosthetics, games, and telepresence.

Technology can be used to dramatically improve the lives of people with physical disabilities. Often this takes the form of medical technology, which is a highly regulated field involving very high development costs and long product lifecycles.

Medical technology is a critical element in supporting people with physical disabilities, and generally focuses on solving problems that are life-threatening or can otherwise be classified as having a medical imperative. Outside of medical technology that directly interacts with the human body, there is an enormous field of assistive technology that can be used to improve the lives of people both physically and mentally but does not have the same level of regulatory overhead.

Technologies that are frequently dismissed as gimmicks or toys, such as home automation systems and IoT devices, can be life-changing for people with disabilities. Not just toys for rich lazy people, home automation can make the difference between an individual being able to live independently or requiring residential care. Even more importantly, it can place the power back in the hands of the individual and give them the ability to control the world around them instead of relying on the help of others.

Because the needs of individuals can vary dramatically, the Open Source ethos of modularity, improvement, adaptation, and sharing is ideally suited to assistive technologies. Existing projects can be rapidly remixed and modified to suit specific requirements by combining open source software, hardware, and fabrication including 3D printing and CNC machining. Open Source technologies can give people with disabilities new powers far beyond what an average human can achieve, turning them into DIY superhumans.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Open_Source_Superhumans.mp4
85. Hot Potato
James Forman, Callum Dickinson

Hot Potato is a message broker for monitoring systems. It sits in between monitoring systems and messaging providers to ensure consistent relaying of messages to on-call staff.

Hot Potato was designed and developed in New Zealand to survive the harshest worst-case scenarios a selection of difficult sysadmins could come up with. The project has proven itself to be easy to maintain, scale and unobtrusive so your on-call staff can get back to sleep easier.

Using Hot Potato won't require you to change your processes, ticketing system, rotations, providers or upset your on-call people. This talk will cover what Hot Potato is, where it fits, how it works, how we got here and what we have been doing to make our on-call staff happier.

The goal of the Hot Potato project is to give on-call people control and freedom while giving your notifications every chance of arriving when you need them, through any provider or connection you might have.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Hot_Potato.mp4
86. Booting faster
Stewart Smith

Doing kernel and firmware development leaves you rebooting computers a *lot*. Modern computers (especially servers) take too long to boot.

Since OpenPOWER systems have a fully open firmware stack (some even with an open BMC stack), we can now attack the problem from *all* angles. This talk covers efforts over the past several years into making POWER based systems boot faster. Is it Linux itself that takes the most time? Firmware? What part of firmware and why? Are the problems for a single socket desktop system different to those from an 8 socket enterprise one? Where have we gotten *worse* and why?

Can we go from close to 10 minutes to less than 30 seconds? 10 seconds? At what point are we purely limited by peoples unreasonable expectations of having PCI, RAM, and output on a display?

We go on a full stack deep dive into what it takes to cold (and warm) boot (and reboot) a system - or at least any part of that which takes time, as well as how we've measured it. We'll touch on code before the power button works, code from before the first instruction is executed, and code all the way up to being able to load a kernel off disk and beyond.

When talking about future improvements, anyone stating "but you're already faster than a bunch of our other servers" will be subtly ssshhed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Booting_faster.mp4
87. AI and AR a match made in heaven
J Rosenbaum

I will discuss my journey to bridge the digital world and the physical world with my Augmented Reality and Artificial Intelligence based artworks and demonstrate artworks made by other artists working in AR and AI while discussing the technologies involved and the impact they will have on development, art and the way we view the world.

From computer vision to style transfers, Generative Adversarial Networks and Image Classifiers and Augmented Reality platforms, I will explore the highs, the lows, the creepy and the exciting moments that come from working as an artist collaborating with a computer.

⚠️ Content warning: This talk contains images of artistic nudity

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/AI_and_AR_a_match_made_in_heaven.mp4
88. RCU's First-Ever CVE, and How I Lived to Tell the Tale
Paul E. McKenney

There was a time when I thought that Linux-kernel RCU was so low level that it was immune to security exploits. However, the 2014 advent of Rowhammer (https://en.wikipedia.org/wiki/Row_hammer) put paid to that naive thought. After all, if the black hats can hit the DRAM, they can surely hit RCU! And in early 2018, an RCU-related CVE duly appeared. Now, RCU was operating as advertised, but it had a usability bug which lured a developer into mixing RCU flavors, which has about the same effect on your kernel's actuarial statistics as would acquiring the wrong lock. So yes, usability bugs are real, so much so that they can result in security exploits! Who knew? Linus therefore asked if I could prevent future such exploits by consolidating the three RCU flavors (RCU-bh, RCU-preempt, and RCU-sched) into one flavor to rule them all. This talk will briefly cover this consolidation, highlighting a few war stories and lessons (re)learned along the way.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/RCUs_FirstEver_CVE_and_How_I_Lived_to_Tell_the_Tale.mp4
89. Desktop to Mobile - Developing for Multiple Platforms without Losing Your Mind
Dirk Hohndel

This is a no-brainer, right? Everyone is just doing mobile apps these days, anyway. So why is this even a talk? Well, imagine you have a desktop application. And that there are good reasons why this should be a desktop application (screen size and ability to talk to random hardware devices, for example). But your users really want a mobile app. And now you need both. And you don't want to throw away all that code. So what do you do?

The Subsurface developers decided to build their desktop and mobile apps from the same code base, using QML and Kirigami to develop the mobile flavor of their Qt app. This solved many problems and opened many doors for us, but it also taught us some harsh lessons about being earlier adopters (this was the first Kirigami app outside their own example apps) and niche users of a technology: to this day I believe we are the only Kirigami app that's both in the Apple App Store and the Google Play Store, and the total number of Qt/QML based applications in both stores is miniscule. Android and iOS packaging are definitely not first class citizens and random other things for those two platforms will randomly not quite work the way you expect.

The presentation will briefly touch on the why (as in: why the heck did you do that instead of writing native Java / objC apps?) and then focus on the how: How can you share most of your code between desktop and mobile, make reasonable trade-offs between functionality, and deal with the challenges of supporting Android and iOS (let alone Linux, Mac, and Windows) from the same code base.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/Desktop_to_Mobile_Developing_for_Multiple_Platforms_without_Losing_Your_Mind.mp4
90. Open Source Quantum Computing
Matthew Treinish

Quantum computers are not just science fiction anymore, with many companies building increasingly more powerful quantum computers. While, concepts in quantum computing have been around for over 30 years, but it hasn't been generally accessible until recently. Despite this quantum computing is still very much in its infancy and there are physical limitations preventing them from being generally usable. But the machines that are available today are useful for experimentation and showcasing certain applications where they will be useful.

Open source software for quantum computing has started being developed as these new machines are being built. Learning the lessons from the history of developing classical computers, there are already several open source SDKs, languages, and libraries being developed despite for quantum computers despite the current limitations of quantum computers. This means as the technology matures and becomes more practical there will already be an open source ecosystem for using quantum computing.

This talk will provide an introduction to the basics of quantum information theory, look at some of the quantum computers out there, explore the open source tooling available for quantum computing, and show how you can use that to write your own quantum programs and run them on simulators and actual quantum computers.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/Open_Source_Quantum_Computing.mp4
91. Around the world in 80 Microamps - ESP32 and LoRa for low-power IoT
Christopher Biggs

Learn how to design and deploy battery powered IoT sensors that can go years between charges.

You could be forgiven for thinking (as I did) that the proliferation of wireless IoT solutions means that implementing environmental monitoring is a simple process. Typically, everything goes swimmingly for the first two hours until your battery runs flat. Many wireless development boards (even the ones with built in battery chargers) are actually not well suited to ultra-low-power applications.

Being truly wireless means (shock) no wires, not even for power. So we rely on battery, and perhaps solar. This brings a host of challenges: selecting the right battery, avoiding power-hungry components, coping with the limitations of a low-power radio platform like LoRa, learning the intricacies of deep-sleep modes, and choosing and using solar cells.

This is a case-study and lessons-learned from a real project for IoT utility metering. What seemed like a simple problem led to a deep dive into ultra-low-power subsystems of modern IoT processors, and the practicalities of the LoRa radio platform.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/Around_the_world_in_80_Microamps_ESP32_and_LoRa_for_lowpower_IoT.mp4
92. Using an Open Source SDN controller to deploy a high-speed production network
Brad Cowie

Faucet is a compact open source OpenFlow controller, which enables network operators to run their networks the same way they do server clusters. Faucet moves network control functions (like routing protocols, neighbor discovery, and switching algorithms) to vendor independent server-based software, versus traditional router or switch embedded firmware, where those functions are easy to manage, test, and extend with modern systems management best practices and tools. Faucet controls OpenFlow 1.3 hardware which delivers high forwarding performance.

This talk will demonstrate how we recently used faucet to deploy a large 100G network for an HPC conference. We will present how faucet works, our network design and an evaluation of the benefits of our approach. For this deployment we were able to greatly simplify the network and replaced many thousands of lines of vendor-specific configuration with a single easy to understand YAML configuration file. Faucet allows users to avoid vendor lock-in in a unique way by implementing the network as specified by the faucet configuration in hardware using the OpenFlow protocol. In this case we demonstrate the control of devices from three different vendors.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Using_an_Open_Source_SDN_controller_to_deploy_a_highspeed_production_network.mp4
93. Game development with Lua, for Beginners
Seth Kenlon

If you're new to programming or new to Linux, you can learn a lot with Lua, the functional programming language used in popular game engines like Unreal Engine, Roblox, Cocos2d, Gideros, and many more.

This tutorial teaches you how to install Lua, how to programme simple scripts, and how to create graphical games using the LÖVE game engine.

No previous experience with programming or Linux is required.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Wednesday/Game_development_with_Lua_for_Beginners.mp4
94. Firmware security, why it matters and how you can have it
Matthew Garrett

A system is only as secure as the least secure component it depends on. Hardening the kernel is a vital part of developing a secure operating system, but if the firmware underneath the kernel is insecure then attackers have an opportunity to sidestep your security and compromise you anyway.

Firmware security research is a rapidly growing field, but the wider world is unaware of a lot of the output. Over recent users we've seen vulnerabilities involving exploitation of code running in system management mode, taking advantage of firmware-level hardware initialisation scripts run on resume from suspend, and even compromise of the management engine - an entirely separate computer that lives inside your chipset.

There's a huge amount of work being done to improve this, but you probably haven't heard about it. This presentation will cover how the state of the art is shifting, along with a discussion of how much of this applies to projects such as Coreboot and Libreboot and whether it's possible to obtain the same level of security without compromising the freedom to run whatever you want on your system.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Firmware_security_why_it_matters_and_how_you_can_have_it.mp4
95. How the quest to prevent time from running out has led me to all corners of the Linux kernel
Deepa Dinamani

Drivers, filesystems, sockets, input events, vdso, python?? and more... Everything that needs to be fixed to prevent from time overflow. This is a talk about some of the problems I expected, and new ones I discovered, on our way to solving the 32-bit timestamps problem for the Linux Kernel.

I work with Arnd Bergmann on solving the y2038 problem.
I would like to paint a picture of how we see the problem: our design principles, strategies and end with where we are today.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/How_the_quest_to_prevent_time_from_running_out_has_led_me_to_all_corners_of_the_Linux_kernel.mp4
96. Doing it the Hard Way - Building a Vulkan VR Engine for Linux
Pete Black

After becoming frustrated with the lack of support for Linux by the major graphics/game engine vendors, Pete set out to climb one of the steeper learning-curves in modern computing, and write his own Vulkan VR Engine.

This talk will provide an overview of the current state of VR technology on Linux, information gained from first-hand experience developing with the Vulkan API, and share a developers journey from 'first-triangle' to some of the cool stuff the engine now supports, some of the doors that this work opened, and what the future holds.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/Doing_it_the_Hard_Way_Building_a_Vulkan_VR_Engine_for_Linux.mp4
97. FPGA based mobile phone: Creating a truly open and trustable mobile communications device
Paul Gardner-Stephen

Modern smart-phones are untrustable. Even if they were open-source, the sheer complexity makes them impossible to meaningfully verify, and therefore trust them. Worse, because they contain major closed-source elements, we lack the digital sovereignty to even attempt such a verification. These concerns are not merely theoretical, the Samsung Galaxy S2 back-door episode, as well as Spectre and Meltdown, and the surveillance facilities purposely built into the cellular network are all evidence that verifyability, trustability, and ultimately, digital sovereignty are all sorely wanted.

Past efforts to make open-source smart-phones have struggled on a number of fronts. First, the chipsets are rarely open-source friendly. Second, even if you find a suitable chipset, by the time you go to market, it is likely already obsolete, and the process of migrating to new chipsets every year is not sustainable for an open-source project. Third, even if you do succeed, there are enough closed-source blobs to make the whole thing untrustable, and without the user holding sovereignty over the device.

We have thus taken a fresh approach to this problem, and created a smart-phone like device that uses an FPGA as the main application processor, and coupled it with an industry standard mini-PCIe cellular modem. The result is a system where you can freely upgrade the cellular modem using commercial off-the-shelf modules, and have complete sovereignty, in that you can create your own FPGA bitstream that defines whatever application processor you want. The cellular modem is left as an untrusted and quarantined "black box". Importantly, the microphone connects to the modem via the FPGA, so it is possible to prevent the cellular modem listening in when it shouldn't be. Indeed, we have gone two steps further: You can cut the power to the modem, or even physically remove it. This modular approach also leaves the door open for a truly open cellular modem to be created, without making us wait in the meantime.

As FPGA programming is not for everyone, and because the device should be fun, and because it is easier to make a less miniaturised device on a shoe-string budget, we are creating prototype devices that double as a portable game console, similar in size to a 3DS XL, and that implements both basic telephony (voice, SMS, contacts) and is backwards compatible with the Commodore 64: The core telephony software we have created is written using an extension to Commodore 64 BASIC, and is already open-sourced, and small enough for a determined user to verify. Naturally, you can use the tune from your favourite C64 game or demo as ringtone and/or hold music, and play your favourite games while on a call. Thanks to our crazy full-crossbar audio mixer framework, you can even have the sound from what you are playing audible to you, but not to the other party. And because of our history with the Serval Project, we are also including some long-range UHF packet radios for good measure.

The resulting franken-phone will not be for everyone, but we believe it represents a significant milestone, in that it could well be the first long-term sustainable open-source smart-phone, and perhaps the first ever smart-phone to offer true digital sovereignty. And play Impossible Mission.

"Telephone Tennis" can finally be a game you can enjoy.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/FPGA_based_mobile_phone_Creating_a_truly_open_and_trustable_mobile_communications_device.mp4
98. Deep Learning, Not Deep Creepy
Jack Moffitt

Massive amounts of data have accelerated advances in machine learning, and companies are collecting as much as they can to power their algorithms. Deep learning has many amazing and practical use cases, but the privacy and social implications of current machine learning systems leave much to be desired.

At Mozilla, we're trying to make machine learning systems that empower people and ensure their privacy. I'll give an overview of deep learning, its applications, and how it all works. Then I'll demo and talk about several machine learning projects at Mozilla, including Deep Speech, speech synthesis, grammar checking, and more. At the end, you'll know what the hype is about, and how you can use these technologies for good.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Deep_Learning_Not_Deep_Creepy.mp4
99. "I'm sorry Dave, I can't do that": Ethics in Software Development
Dr. Morgan Leigh

⚠️ Content warning: This talk contains an image of dead animals

We all know how bad things went when the HAL 9000 computer was asked to lie in the film 2001: A space odyssey. As we enter into an era where all kinds of things have programming we need to establish a firm ethical foundation to avoid such disasters.

As an artifact of late stage capitalism, software development has at its core the precept that if it makes money it's good. Developers have from the very first been tantalized with the prospect of riches, the core ethos of startup culture. This pursuit of riches above all compromises ethical development.

Today with the vast expansion in the number of developers, most developers today are just working to pay the bills. When one depends on one's job to pay the bills one is likewise compromised when it comes to ethical boundaries.

Are you really going to risk your options or quit your job just because they want you to cut a few corners or compromise users a tiny bit? It's only a wee bit. Honest. No one will know. We'll put it in a binary blob...

Do developers need an ethical conscience, or are we just following orders? How do we decide where the line is that we can't cross? When do we have to start saying, "No, I won't do that thing". If Cambridge Analytica has taught us anything it's that there is a line we shouldn't cross. There are some things more important than money. It's time to work out what they are.

In this talk I will help you to work out where your own ethical line is and show you the consequences of crossing it.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/Im_sorry_Dave_I_cant_do_that_Ethics_in_Software_Development.mp4
100. Rust for IOT
E. Dunham

Is Rust ready for the embedded world yet? If your IOT project is on ARM or MSP430, it already has native support in the Rust compiler, and AVR and RISC-V have compiler forks available.

But architecture support is only the first challenge: If you're used to writing Rust for hosts that run an operating system, the paradigm shift of having to do everything yourself in the embedded world can be jarring.

This talk will introduce the basic techniques for writing Rust to run microcontrollers, and survey outstanding embedded rust projects already available in the ecosystem.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/Rust_for_IOT.mp4
101. MR Security: Learning from IoT's Mistakes
Diane Hosfelt

Virtual and augmented reality technologies are becoming mainstream, and their privacy implications are staggering. As a security engineer with the Mixed Reality (MR) team at Mozilla Research, part of my job is to explore what privacy and security will mean in an immersive world.

VR and AR create a world that blurs the lines between technology and reality, with all of the security challenges that this entails. Intensely personal traits like a user’s gait and eye-tracking (just two of many examples) can and sometimes must be exposed for immersive experiences to work correctly. VR also introduces questions about personal (virtual) space and location data ownership (can I pop into your kitchen and hang out in AR? or leave some virtual 💩 on your doorstep?). It’s our job as technologists to figure out how to build systems robust against abuse.

By looking back to what we got right and what we could have done better the last time we invited new technologies into our homes and lives, as well as discussing the new technological and legal challenges unique to VR, this talk will explore our current opportunities to get VR less wrong than we got IoT.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/MR_Security_Learning_from_IoTs_Mistakes.mp4
102. Home Automation, just do it
Alastair D'Silva

If you're anything like me, you've probably had grand ideas about home automation, but have been dragging your heels, in part due to the numerous ecosystems available, and the massive integration challenge that lies ahead.

This hands-on workshop will provide you with the tools necessary to get you going on the path to taking control of your home.

This workshop will consist of a hardware kit (Estimate: < AUD$100, you get to keep the kit afterwards) which will include a Linux based SBC (TBD), microSD card, power supply, 3D printed case, relay board, pushbutton switches, and 433MHz radios, which will form the core of your home automation controller.

During the workshop, you will configure HomeAssistant on your new computer in order to control the relay outputs via local switches, the HomeAssistant interface, and even your garage remote control (if you have one that is compatible with the provided radios).

We will also discuss how to tie in third systems, such as Belkin's Wemo, and custom integration via MQTT.

103. What's new in control groups (cgroups) version 2?
Michael Kerrisk

Control groups (cgroups) version 1 was released in 2008, and within a short time people realized that there were a number of problems that resulted from its uncoordinated design and implementation. Soon afterwards, work began on fixing the problems--work that lasted around 4 years and resulted in the release of cgroups v2 in 2016. Even then, much work remained to be done, with the absence of some important features blocking widespread adoption of cgroups v2. One of the main logjams was finally broken at the beginning of 2018 with the merging of the cgroups v2 CPU controller, and it seems likely that the remaining missing pieces will be added in the next few kernel releases. It seems likely that cgroups v2 will become more widely used in the not too distant future. (One of the notable users of cgroups v1, systemd, is already migrating to cgroups v2.)

In this talk, I'll briefly consider some of the problems in cgroups v1 that motivated the cgroups v2 redesign, and then go on to look at the differences and new features in cgroups v2. I'll also look at what pieces are still missing in cgroups v2 and some other possible changes that come to cgroups v2 in the future. Some familiarity with the cgroups mechanism will be assumed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/Whats_new_in_control_groups_cgroups_version_2.mp4
104. Hardware hacking 101: There is plenty of room at the bottom
Federico Lucifredi

This is a live demonstration of hacking into the processor embedded in an SD card, effectively turning the device into a potentially covert Raspberry Pi-class computer under your complete control. The ARM926EJ-S ARM processor made its appearance as the embedded CPU in Transcend’s WiFi-enabled SD cards, clocking in at an impressive 426 BogoMips – we can’t possibly leave that territory unexplored, can we?

In this session we root the card’s own CPU, install a more featureful OS, and explore the system’s common and unusual capabilities (in hardware AES encryption and native support for Java bytecode among them). These provide plenty of building blocks for our projects.

I will review the hardware, its capabilities, how to breach its security, and how to enable it with top-class network configuration at boot-up, on nearly any network. I will then show how to build and install additional software and customize the device, using shell script and Perl, for workloads that fit its minute size and low power requirements.

Clearly, complete control of such a hidden computer running with full network connectivity can be used in network penetration scenarios. We’ll discuss applicable security threat countermeasures.

We close the session with a review of similar exploits against hard drive controllers. There is plenty of room at the bottom, and opening these computer-within-the computer configurations create interesting miniaturized automation scenarios alongside the obvious, more ominous security aspects.

Use your newfound knowledge for good, with great power comes great responsibility!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/Hardware_hacking_101_There_is_plenty_of_room_at_the_bottom.mp4
105. Learn Complex Skills, From Anywhere: Combining Django, Ansible and OpenStack to teach any tech skill
Florian Haas

Professional skill-building is challenging, particularly when the skill to acquire is about distributed, scalable platform technology. In this talk, I cover an open-source skill-building platform that is 100% Python: built on Open edX and heavily involving Django, Ansible, and OpenStack.

The information technology industry is currently dealing with an interesting challenge in professional skill-building: almost every new technology developed in recent years has been complex, distributed, and built for scale: Kubernetes, Ceph, and OpenStack can serve as just a few representative examples. Loose coupling, asynchronicity, and elasticity are just some of the qualities frequently found in such systems that were entirely absent in many of the systems we built only a few years ago. As a result, people comfortable with building and operating these complex systems are hardly found in abundance, and organisations frequently struggle to adopt these technologies as a direct result of this scarcity: we are dealing with a skills gap, not a technology gap.

This means that we need novel ways to educate professionals on these technologies. We must provide professional learners with complex, distributed systems to use as realistic learning environments, and we must enable them to learn from anywhere, at any time, and on their own pace. One excellent way of doing this is to use the capabilities of the Open edX platform to integrate a learning management system with hands-on, on-demand lab environments that can be just as complex, and just as distributed, as production systems. This allows anyone interested to develop a professional skill set on novel technology at minimal cost, and without the need for costly hardware platforms for evaluation.

In this talk, I will give a rapid technical introduction to the core components of this free and open source (AGPL 3/ASL 2) all-Python platform:

* edx-platform, the core learning management system (LMS) and content management system (CMS), built on Django;
* edx-configuration, the automated deployment facility to roll out the Open edX platform, built on Ansible;
* and finally, the Open edX XBlock extension system and its integration with OpenStack, also itself an all-Python cloud platform, in order to provide on-demand lab environments from both private and public cloud environments.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Learn_Complex_Skills_From_Anywhere_Combining_Django_Ansible_and_OpenStack_to_teach_any_tech_skill.mp4
106. Why linux.conf.au continues to amaze 20 years on!
Steven Hanley, Angus Lees, Hugh Blemings

Linux.conf.au has justifiably earned an enviable reputation in the Linux and broader FOSS community as being one of the most consistent and worthwhile conferences in the annual calendar.

This session will look under the hood at what makes LCA special and tease out some of the unique qualities that have served it so well (and in some cases not so well) over the years.

While there will certainly be a fun “trip down memory lane” element to the session, the speakers will be focussing on the specific consistent nuts and bolts that make LCA work - much of it often invisible to those attending.

The three presenters have all had the good fortune to have not only attended CALU and all the LCAs since, but also between them to have been involved in their running in various capacities from conference director to speaker, Linux Australia representative to BoF leader.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Why_linuxconfau_continues_to_amaze_20_years_on.mp4
107. Optimising ID Allocation for low-memory devices
Matthew Wilcox

The Linux kernel needs to allocate small identifying numbers for many things (e.g. file descriptors, process IDs, SCSI devices, USB ports, network devices). The implementation of this crucial functionality was surprisingly memory-hungry and so it needed to be rewritten.

This case study shows
- How implementing functionality in the Linux kernel (or any project of sufficient
complexity) requires being aware of implementation details of other parts of the
project.
- The perils of half-complete migrations.
- How easy it is to overlook hundreds of kilobytes of memory leaking when you have
gigabytes of memory in your system.
- The importance of API design.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Wednesday/Optimising_ID_Allocation_for_lowmemory_devices.mp4
108. Designing & manufacturing a custom embedded linux machine.
Julien Goodwin

These days there’s many cheap & abundant options for embedded Linux machines, from Raspberry Pi, BeagleBone and their derivatives to dozens of more obscure options. But what if none of those options work for your use case, perhaps a needed pin is in-use by an onboard peripheral, all the existing boards with the right features are too big, or just to integrate a transceiver.

In the past designing an embedded machine capable of running Linux required dealing with low-level concepts such as DRAM timing, requiring an effort more than most hobbyists or small scale commercial uses could justify. However there are now far more integrated components making this within the reach of even hobbyists.

In this talk we’ll cover the design of a custom BeagleBone variant forming the core of custom NTP server project, preparing it for manufacturing, and the low-level configuration for Linux to work with this new board.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Wednesday/Designing_manufacturing_a_custom_embedded_linux_machine.mp4
109. Bugs in your server
Joel Stanley

Service processor privilege isolation and getting caught with your pants down

Modern servers contain a service processor - a Baseboard Management Controller (BMC) System On a Chip running a software stack that enables out-of-band monitoring and management of the server. Management and monitoring are necessary in cloud and dedicated server environments where machines are leased out, and a fundamental property of such a system is the separation of the management and workload security domains.

BMC hardware designs and firmware have traditionally been hiding in the shadows, though recent research has begun to shine a light into the ecosystem. The bulk of the research has relied on exploiting software flaws in existing BMC firmware implementations. By contrast, this talk will demonstrate methods of gaining complete persistent control of the BMC using a variety of useful hardware features.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Wednesday/Bugs_in_your_server.mp4
110. BlueHackers: a decade
Arjen Lentz

It started with Arjen doing the last lightning talk at OSDC 2008… a quick show of hands on who else had dealt with (or was dealing with) depression and related matters. Everybody had a look around, and thus knew that they weren’t alone.

Afterwards, there was more positive feedback which continued over email in the days that followed. Someone suggested starting a group, and bluehackers.org was born.

What started as a spur of the moment thing actually turned out to be a neat idea, and we've done some good since. Elsewhere on the planet, others have started similar initiatives - fabulous!

Sadly, we have also lost a number of fellow community members over the years, which tells us that this is an important topic that we can't let drop off the radar. I know that we've also saved some lives, and from that we know that we can make a real difference.

In this talk, we'll review where we've been and where we might go in the future. We'll also look at the relationship between mental health and our industry, and how the broader public is increasingly also closer to our space. Since we've been there longer, we have gained some insights that could benefit more people.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Wednesday/Bluehackers_a_decade.mp4
111. Right to Not Broadcast
Karen Sandler

As we increasingly live in a world where our devices are interconnected, the line becomes blurrier between strictly private information and information that is shared. From medical devices to in home security systems to oral medication with sensors embedded, our most personal data is often being broadcast by default, sometimes without appropriate security measures and without an off switch. Because of this, it is essential that any device that interacts with personal information have the option of having connectivity disabled. This talk will explore the current state of personal devices and the steps we need to take to make sure we all have the right not to broadcast our most personal information when we need most to protect it.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Wednesday/Right_to_Not_Broadcast.mp4
112. Keynote: Personal Branding for the Security Conscious (C1)
Shannon Morse

Shannon Morse leads the largest information security podcast and video series on the web, educating countless individuals about security and privacy for the masses. With over 1500+ videos produced, Shannon has developed a career in infosec as an influencer and supporter for up and coming professionals. Shannon's career mixes the worlds of hacking and open source, while introducing the concepts of social media to the security conscious mindset. Using her years of experience creating a new job title that didn't exist a decade ago, Shannon shares her thoughts on personal branding in the infosec industry, not only to get the job you want, but to be respected as an equal in the community.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/Keynote_Personal_Branding_for_the_Security_Conscious_C1.mp4
113. Awesome Monitoring Infrastructure Using the Elastic Stack
Mark Walkom, Karen Carcamo

IoT is great, until something breaks or you want to see how things perform at scale! To handle the volumes of data that any IoT project can generate, many developers default to Open Source tool chains to capture and analyse logs and metrics, and then pinpoint errors, faults or inefficiencies in their systems.

One of the most widely used Open Source tools for this is the Elastic Stack:

* Beats as a lightweight agent/forwarder of data.
* Logstash for further parsing and enrichment.
* Elasticsearch doing the hard work of storing and analysis.
* Kibana for powerful visualisations.

This workshop gives you an overview of the four technologies, how they work together and how, from microservice logs to IoT metrics to containerised apps, it has you covered.

At the end of the workshop, you'll walk away with a set of connected Docker containers capturing logs and metrics from your laptop, a head start on dashboards for analysis, and ideas to deploy for your next project.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Thursday/Awesome_Monitoring_Infrastructure_Using_the_Elastic_Stack.mp4
114. The AV1 Video Codec
Timothy B. Terriberry

Last year, the Alliance for Open Media released its next-generation video codec AV1. It achieves better compression than proprietary competitors, while its patents can be licensed via a royalty-free, open-source friendly license. With a broad array of industry support including all major browser vendors, many hardware partners, internet streaming video and conferencing providers, we think this is our best chance yet to create a successful video codec that achieves wide deployment.

However, agreeing on the standard was just the first step. This talk will discuss the road from specification to production, the current state of AV1 deployment, and our own efforts to write an AV1 encoder in Rust, rav1e. It is intended for a technical audience, but does not require previous signal processing experience.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/The_AV1_Video_Codec.mp4
115. Open Source. Open Data. Changing lives for the better.
Liz MacPherson

In my role as the Government Chief Data Steward my focus is on building a foundation to enable government to better manage New Zealand’s data, maintaining and building trust in its use. In this role, I also leave New Zealand’s open data programme.

There is so much to be gained by empowering and enabling government agencies to open their data, so that it can be safely shared and reused to inform decision-making and ultimately improve outcomes for people.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/Linux_community_culture_transforming_the_world.mp4
116. Improving Graphics Interactivity - It's All in the Timing.
Keith Packard

Interactive applications, which includes everything from real time
games through flight simulators and virtual reality environments,
place strong real-time requirements on the whole computing environment
to ensure that the correct data are presented to the user at the
correct time. This requires two things; the first is that the time
when the information will be displayed be known to the application so
that the correct contents can be computed, and second that the frame
actually be displayed at that time.

These two pieces of information are managed inconsistently through the
graphics stack, making it difficult for applications to provide a
smooth animation experience to users. And because of the many APIs
which lie between the application rendering using OpenGL or Vulkan and
the underlying hardware, a failure to correctly handle things at
any point along the chain will result in stuttering results.

Fixing this requires changes throughout the system, from making the
kernel provide better control and information about the queuing and
presentation of images through changes in composited window systems to
ensure that images are displayed at the target time, and that
the actual time of presentation is reported back to applications and
finally additions to rendering APIs like Vulkan to expose control
over image presentation times and feedback about when images ended up
being visible to the user.

This presentation will first demonstrate the effects of poor display
timing support inherent in the current graphics stack, talk about the
different solutions required at each level of the system and finally
show the working system.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/Improving_Graphics_Interactivity_Its_All_in_the_Timing.mp4
117. Sequencing DNA with Linux Cores and Nanopores
David Eccles

The Oxford Nanopore MinION is a small stapler-sized device that is quietly disrupting the way that the world looks at the world. Despite what TV shows will tell you, deoxyribose nucleic acid (DNA) is not a bunch of letters on a computer screen. Those letters represent a physical thing: long, stringy whiteish stuff that frequently has a gel-like consistency and an amazing ability to clump together with itself.

The MinION is a DNA sequencer. DNA sequencing is the process of turning the physical thing of DNA into a model of that thing on a computer. Using this pocket-sized device, researchers have been able to sequence DNA in the jungle, at the bottom of the ocean, in Antarctica, and on board the International Space Station.

For LCA, the challenge will be to prepare, sequence, and analyse a sample of DNA over the course of single talk, with no external power source (apart from the laptop battery), and using freely available software and DNA sequence databases. LinuxConf attendees will be given access to the DNA sequences produced during the talk, and are free to add their own creative interpretations of long strings of four different letters.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/Sequencing_DNA_with_Linux_Cores_and_Nanopores.mp4
118. A Long Day's Journey Into Backups
Rachel Kelly

This is a story of the journey taken to have effective, safe backups in customer environments. Part history (four separate solutions implemented), part prescriptivism (use the cheaper storage solution, my GOD use the cheaper storage solution), part actual technical solutions (tar, S3, NFS/EFS), let's talk about the thousand solutions we tried, and what is really and truly working for the company and for me (and you!), the operations engineer.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/A_Long_Days_Journey_Into_Backups.mp4
119. SymbiFlow - The next generation FOSS FPGA toolchain
Tim 'mithro' Ansell

[SymbiFlow](http://symbiflow.github.io) aims to be the "GCC of FPGAs" - a fully open source project which supports multiple FPGAs from multiple different vendors.

Due to their reconfigurable nature, FPGAs make hardware problems into software problems and enable anyone to building custom integrated circuits. This means you could create *your* ideal microcontroller, not what some manufacturer *thinks* you want. You can have the *exact* right set of peripherals including as many SPI, I2C or CAN as you want!

The FPGA innovation has been around since 1980s but has previously require getting giant closed source proprietary black boxes from the FPGA vendor (10 gigabytes or more!). Thanks to SymbiFlow this is no longer the case!

SymbiFlow currently supports the Lattice iCE40, Lattice ECP5 and Xilinx 7 series FPGAs. This presentation will give you an update on the current status of the project. What currently works, the future roadmap and how you can help with the project.

Come find out about how a small group of hobbyists are changing the world of FPGA development!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/SymbiFlow_The_next_generation_FOSS_FPGA_toolchain.mp4
120. Autopsy of a Browser
Erin Zimmer

Before there was the Internet of Things, there was the Internet of Webpages. And, unless you're really committed to Curl, you probably access the Internet of Webpages using a browser. But browsers are a bit like digestive systems - everyone has one, but you don't really know how it works, and sometimes it makes weird noises or bad smells.

Doctors learn about bodies by performing autopsies, so let’s try the same thing with a browser. We’ll find some browsers that died of natural causes, and have a poke around inside. We’ll start with a primitive browser, that only has the ability to display text and follow hyperlinks. From there, we can follow the evolution of images, layouts, CSS and JavaScript. Along the way, we’ll gain some insights into the historical circumstances that led to modern browsers being the way they are, and hopefully end up with a better understanding of some of their quirks.

*No browsers were harmed in the making of this talk

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/Autopsy_of_a_Browser.mp4
121. The Robots Won't Take Away Our Jobs — Let's Reframe the Debate on Artificial Intelligence
Martin Krafft

A trending theme in the Industry 4.0 discourse is that robots and other forms of artificial intelligence are going to take away our jobs. Such predictions are then often accompanied by dystopic scenery of humans commanded by anthropomorphic machines, painting a bleak future for humanity. It goes without doubt that the fourth industrial revolution will effect change upon society, in some ways similar to its three predecessors, and in others different in ways we cannot yet imagine.

However, the robots are not going to replace us, for humans have distinguishing traits, some of which are rooted in millions of years of evolution, and others directly resulting from the way humans interact with their surroundings. While we're likely to see the end of certain lines of work, just like today nobody works shoveling coal on trains, or operating the telephone for others, we will not only adapt to change, but we will be the ones leading it.

Big data and data science have given us machines capable of identifying correlations in data that were previously invisible to and unfathomable by humans. In what ways can these be considered intelligent? What's missing, and where are the boundaries? Can these be crossed? Ever? Where are the potentials, and how do we better deal with machines making decisions that affect our lives? What are the benefits of asking these questions?

In this presentation, I explore the nature of intelligence, and what makes humans unique, and robots less so. I would like to take the audience on a "tour de force" of 40 years of "New AI" research, which I studied and lectured at the Artificial Intelligence Laboratory of the University of Zurich, one of the leading laboratories in this field.

My goal is not just to ask questions, or provide simple answers. There are none. Instead, I would like to empower and invite the audience to reframe the debate about artificial intelligence and robots, especially pertaining to the future of work. Progress in the field is accelerating, and we need to shift perspective and ask ourselves: "what do we want from the robots?", rather than "what are they going to do to us?". Our frame of this debate will inform the way we think about AI and robots, and affect the decisions we make, individually, and as society, about the roles of robots and humans, the potentials of automation, and the ethical and moral challenges associated with the revolution dawning upon us.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/The_Robots_Wont_Take_Away_Our_Jobs_Lets_Reframe_the_Debate_on_Artificial_Intelligence.mp4
122. Finite state machines: a design pattern for FPGAs and React
Tessa Bradbury

At my current job we use React as our frontend javascript framework. After just joining the company, I was reading through the documentation when it suddenly hit me that it was describing was a finite state machine. I knew about finite state machines! I did those back at university! And that was when I realised the most useful unit I did at university for working with React was the FPGA and microprocessor course.

This talk will cover what finite state machines are, how they are useful across the width and breadth of software development, including both IoT and javascript, and some key things to remember when implementing them.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/Finite_state_machines_a_design_pattern_for_FPGAs.mp4
123. Using containers to analyse the impact of climate change
Eric Burgueño

Predicting crop productivity and environmental outcomes of agricultural systems requires modelling quantitative data around soil characteristics (e.g.: nutrients and soil water dynamics) and climate information. Traditionally, the scientific research community runs these simulations using standard desktops.

When the simulations need to be done at scale (ie: wide-area, or landscape scale), detailed quantitative soil information is not always available. This leads to generalisations and simplifications, which may affect the resulting estimates in ways unknown. However, when there is detailed information, the compute capacity required to analyse that data grows beyond what a standard desktop can handle within the average human lifespan.

In this talk, I will share our experiences creating a new data processing pipeline using software containers (Docker and Singularity), that allows processing of vast amounts of high-resolution soil and weather data in a scalable way. This system has already been used in a case study to simulate productivity and environmental aspects of a multi-year crop rotation system across a catchment in the Hawke’s Bay region of New Zealand, at a 5 arc-min grid-cell resolution (~5 km grid size).

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/Using_containers_to_analyse_the_impact_of_climate_change_and_soil_on_New_Zealand_crops.mp4
124. GStreamer WebRTC - The flexible solution to web-based media
Matthew Waters

Currently, the most popular and most featureful WebRTC implementation is webrtc.org used in Chrome and Firefox. It works well for browsers, but the Native API has several shortcomings that make it a less-than-ideal choice for use-cases outside of browsers for native apps, server applications, and IoT use cases.

I will discuss those shortcomings and present a new open-source WebRTC implementation that we at Centricular wrote and contributed to the GStreamer project, and will talk about how this enables sophisticated, flexible, and efficient multimedia use-cases across a wide range of devices.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/GStreamer_WebRTC_The_flexible_solution_to_webbased_media.mp4
125. Faucet SDN Tutorial
Brad Cowie

In this hands-on tutorial we will install and configure the Open Source Faucet SDN controller. On your laptop you will be configuring a virtual network topology using Open vSwitch as a switch and network namespaces as hosts. This network will be controlled via the OpenFlow protocol by a faucet controller. We will investigate many different Faucet features such as VLANs, ACLs, Routing, etc. The network we configure will be monitored by Prometheus (over OpenFlow not SNMP) and we will make some dashboards in Grafana to view the performance data stored in Prometheus.

There is a lot of flexibility in the tutorial to accommodate both beginners as well as advanced users to the world of SDN.

What is Faucet? It is a compact open source OpenFlow controller, which enables network operators to run their networks the same way they do server clusters. Faucet moves network control functions (like routing protocols, neighbor discovery, and switching algorithms) to vendor independent server-based software, versus traditional router or switch embedded firmware, where those functions are easy to manage, test, and extend with modern systems management best practices and tools. Faucet controls OpenFlow 1.3 hardware which delivers high forwarding performance.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Thursday/Faucet_SDN_Tutorial.mp4
126. Taking it to the Nest Level - Nested KVM on the POWER9 Processor
Suraj Jitindar Singh

Nested virtualisation is the idea of running a virtual machine within another
virtual machine. The new IBM POWER9 PowerPC processor has increased hardware
support for nested virtualisation and Suraj has been in the process of
developing software support for this feature. In this talk he will delve
into the rational behind developing this, the implementation details including
the changes involved to KVM and qemu to support this feature, the challenges
faced, and finally a discussion about the current state of the project and
future work still to be completed. Suraj will also attempt to answer the
question on everybody's lips "but how deep can you nest?"

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/Taking_it_to_the_Nest_Level_Nested_KVM_on_the_POWER9_Processor.mp4
127. Linux Kernel Licensing - toward "grep"ability.
Kate Stewart

During the Maintainer Summit in 2017, the guidelines for adding SPDX identifiers to the Linux kernel source files were agreed on, and documented properly a couple of months later. While the Linux Kernel is GPL-2.0-only at the top level, there are lots of other licenses included in the source files. Linux kernel contributors are now able to accurately express the license a file is released under with a single one-line comment that can be "grep"d for, and it satisfies the conditions of using the DCO. This talk will overview the state of licensing information in the Linux kernel, how ambiguous files can be cleaned up, and progress made in 2018 towards the "grep" goal by the community.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/Linux_Kernel_Licensing_toward_grepability.mp4
128. Go All-In!
Bdale Garbee

In the beginning, the motivation for developing and using Free Software centered on a shared value of enabling and maintaining end user freedom. As more and more developers joined Free and Open Source Software communities and software innovation moved largely to openly collaborative spaces, the economic benefits for companies of using FOSS technology became immense. Not surprisingly, this has led us to an era where we talk more about benefits than core FOSS values, which unfortunately can lead us to make choices that aren't good long-term bets!

The immense growth and success of FOSS has led to a world in which virtually every computing device on the planet contains at least some open source component. But even today, many companies fear deeply engaging in the collaborative development model, insisting instead on licences and governance terms for the FOSS projects they interact with that allow them to be pure consumers of innovation.

This talk will review the economics of collaboration, and the related essentials of FOSS project longevity, illuminating the difference between consumptive and fully engaged participation. The session will conclude with concrete suggestions on how to maximize the value of participation in FOSS for users, developers, and corporate decision makers... and why the best bet may be to go all-in!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/Go_AllIn.mp4
129. Using Open Hardware from my shirt to OS testing for Google's Fuchsia
Marc MERLIN

TL;DR: come learn how going back to the days of smaller CPUs is interesting, fun, and can be useful for many applications.
What you can expect to learn outside of the fun factor and the rewarding learning experiences:
- get an overview of what you can learn and do beyond what's mentioned in your basic arduino book
- some of the joys of reliving what the pioneers who built computers and drivers in the Steve Wozniak days, went through, despite how much easier it is today
- how that new knowledge can be applied to various real projects like a fancy lit shirt, not losing a multi thousand dollar RC plane, or helping test new hardware at work
- how despite how shiny your hammer is, not everything is a nail: where I haven't used microcontrollers, and why.

Details:
Let's face it, computers have become entirely too boring. You use high level languages, some even keep track of your memory and try to stop you from writing bugs. You have more cores, more Mhz, and more memory than you know what to do with.
- Has your life has started losing meaning as a result?
- Are you not sure how many bits are in a byte?
- Are you tired that you haven't had to deal with compiler induced bugs in too long (if ever)? Or you don't ever use compilers?
- Is it boring that someone has already written the drivers for the hardware in your computer?
- wouldn't it be more fun to write single threaded code without an OS then a boring small application on a computer that runs hundreds more at the same time?
- Do you regret never having to pull a voltmeter or logic analyser to debug your code?

Fear no more: Jon Oxner and his team have been offering an open hardware miniconf at LCA since 2010, which will bring you back to the days where computers were hard, and you earned it :)

Thanks to Jon and his team-mates, I got into arduino and other open hardware microcontrollers in 2011. This talk will give you a taste of what I was able to learn as a result, and what you can learn too:
- Once past the basic I/O on arduinos, I got to write a callback based color LED changer. Learn why callback programming is harder and yet important.
- To go several notches up, I wrote a interrupt driven tricolor matrix line scan driver with Adafruit::GFX support. Learn about actual interrupt programming and GCC's volatile
- I had to write a LiquidCrystal Text LCD driver for OHMC's Pebble V2 project. Learn about pulling out a data sheet and comparing it with your board's wiring.
- Because I didn't learn my lesson, I ended up writing 5 different drivers for the 2017 OHMC IoTuz ESP32 based board. On that one, you'll learn that you should wait for another sucker to do the work :)

But you shouldn't just learn to program open hardware on LCA Open Hardware MiniConf boards for fun, it will come in handy later:
- After losing a multi thousand dollar Ardupilot based plane I built to a motor failure in flight, I was able to modify the arduino based On Screen Display board to detect future motor failures and flash them on screen
- I felt shy and without friends at parties, as well as too dark at burning man, so I made nice ESP8266 controlled shirt and pants with my own patterns
- then I went overboard and added 1536 LEDs in 2 panels, one front, one back on my 2nd version of the shirt
- And because a 768 LED matrix wasn't big enough, I got suckered into building a 4096 LED one soon thereafter. Great for burning man, though: https://www.youtube.com/watch?v=HH1rhg3PRgk
- At work, I help with testing of our new hardware with the Fuchsia operating system, which requires remotely controlling dev boards, to reboot them when they are crashed, or other simple things like hitting GPIOs if needed, or potentially emulating a keyboard, a mouse, or even a USB boot device with a new OS image.
- As a counterpoint, I'll also go into microcontroller uses I haven't done, and why.

I will go into this list of examples, how they were fun, useful, or both, and hopefully encourage you to do the same.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/Using_Open_Hardware_from_my_shirt_to_Google_Fuchsia.mp4
130. Network Monitoring with AMP
Brendon Jones

AMP is a distributed network monitoring platform designed to continuously perform active network measurements, capable of monitoring both network and service performance. Currently available tests include ICMP and TCP latency, UDP DNS latency, TCP throughput, HTTP performance and video streaming performance. Scheduled tests run continuously on the probes and report data to a central collector (or into your favourite storage/graphing tool) to generate graphs. The same tests can also be run as standalone tools from the command line as required.

There are AMP probes deployed at most universities in New Zealand, at major sites on the REANNZ network, and at many New Zealand Internet Service Providers, all with publicly available data. AMP is also being used internally by a number of ISPs to monitor customer experience and infrastructure performance.

This talk will cover the architecture and design of the AMP platform, as well as how the tests work, how the data gets reported and some of the issues we've encountered while trying to take accurate measurements. In particular it will show some of the challenges involved in creating a test to measure video streaming performance using a headless web browser. It will also explore some of the data that has been collected over the last few years and showcase some of the more impactful network events, misconfigurations, or generally interesting behaviour that has been observed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/Network_Monitoring_with_AMP.mp4
131. The kernel report
Jonathan Corbet

Back by popular demand: an overview of what the kernel development community has been up to and what can be expected in the near future. Attendees will gain a better understanding of what has been happening in this huge and fast-moving project — and what the current challenges are.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/The_kernel_report_3.mp4
132. Adding location awareness with GPS technology
Mike 'Hamster' Field

Positioning technology is now ubiquitous. This technology was originally restricted to the military and commercial transport, it is now being built into everyday products such as cars, cell phones and watches.

A brief overview of the three GPS segments will be introduced - Control Segment, Space Segment, User Segment, detailing how each of these cooperate to provide the user's location in both space and time. Methods will be covered that allow the receiver to acquire the civilian Coarse/Acquisition (C/A) satellite signal, track the signal until a solid lock is obtained, allowing the reception and decoding the down-link navigation data.

A demonstration of technique will be performed by decoding previously acquired Radio-Frequency data. This is a level of detail usually hidden from the everyday GPS user and not normally seen, and will illustrate such concepts as the difference between a cold and warm start, the almanac, time to first fix and number of active channels.

Inexpensively GPS hardware receivers are available from many suppliers, including hobby stores like Jaycar, commercial suppliers, and internet retailers such as Ali Express. As with all areas of technology, GPS receivers have their own jagon - understanding these is important selecting an appropriate module for a project. A few different inexpensive GPS hardware modules will be reviewed and a Raspberry Pi Zero running Linux will illustrate the low cost and accessibility of the hardware.

To communicate with a GPS module the lingua franca of positioning systems is NMEA 0183 sentences, a standard developed by the National Marine Electronics Association. The NMEA data stream will be explained - how to parse them, how to detect data errors, what sorts of information it can provide.

The efficient and correct processing of location data is important, and a few techniques will be covered that can be used to handle different use-cases. A brief overview of the Latitude, Longitude, Altitude (LLA) and Earth Centered, Earth Fixed (ECEF) coordinate systems will be provided, and followed with examples of how you can compute using GPS data and either a 'flat earth', spherical or WGS 84 ellipsoid model.

Although GPS is a receive-only system it is not without security issues. Various attacks are possible, including shielding, jamming, spoofing, denial of service, hardware interception and (perhaps most interestingly) attacks against GPS receiver firmware. Other issues arise from the wider problem of securing access to GPS information in cloud-based services, and examples of what unexpected information may be revealed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/Adding_location_awareness_with_GPS_technology.mp4
133. Beach Wreck Ignition: Challenges in open source voice
Kathy Reid

This session will look at why open source voice is so difficult, and what strategies are currently being applied to meet these challenges.

Real time speech to text- including hardware limitations, difficulties with on-device STT, challenges with cloud based STT including responsiveness.

Machine learning and training challenges - including debugging poor fit models, sourcing significant data sets and training new models

Multiple languages, localisation and internationalisation - including language idiosyncrasies, slang and handling intent collisions across multiple Skills

Voice user interaction - the challenge of producing a voice interaction that is both useful AND human-like

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/Beach_Wreck_Ignition_Challenges_in_open_source_voice.mp4
134. A case study in incrementing a language's major version: PHP
Adam Harvey

In 2015, the PHP project released version 7.0 of the PHP language. Doing so was
the culmination of several years of discussion and hard work to resolve what a
new major version would look like, what would be included, and most
importantly, what would be broken for existing users.

In the end, PHP 7 was released with almost no backward compatibility breaks for
well written, modern PHP 5 code. As a result, uptake of PHP 7 after two years
has been — depending on which source you use and how you measure it — between
33% and 67%.

In this talk, I'll discuss how the PHP team balanced the carrot and the stick
to encourage adoption, and compare how PHP's approach to a major version bump
has contrasted with other languages in the recent past.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/A_case_study_in_incrementing_a_languages_major_version_PHP.mp4
135. Teaching 9-10 year olds to code
Robert Ancell

For the last year I have run a Code Club (https://codeclub.nz/) at my local primary school. In this talk I will cover:
- Why starting a club is challenging, fun and rewarding.
- How the Code Club organization makes it easy to get going quickly.
- Finding the right software and hardware to be able to run the club.
- The good and bad aspects of starting with Scratch (https://scratch.mit.edu/).
- How to migrate children to using Python.
- The new material I developed for the children based on observations of how they learned and what motivated them.
- The appropriate use of hardware (Raspberry Pi and BBC micro:bit)
- Challenges in attracting more volunteers to the club.
- Keeping a good gender balance.
- Fundraising.
- Unexpected requirements that led me to develop some new software.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/Teaching_910_year_olds_to_code.mp4
136. Open Source Tools for Publishing and Processing Earth Observation Imagery
Paul Haesler

There are now several earth observation satellites in orbit around our fair planet, beaming down huge volumes of gorgeous imagery every day. Digital Earth Australia (DEA) is a platform managed by Geoscience Australia (GA) to make this imagery of Australia available to government, industry and researchers for easy use. At the heart of DEA is the Open Data Cube, an open source Python platform for working with Earth Observation data. Data 61 has been working with GA to develop open source web services and clients to make this rich source of data accessible to both expert users and non-technical people who just like to look at cool satellite images in the comfort of their own home.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/Open_Source_Tools_for_Publishing_and_Processing_Earth_Observation_Imagery.mp4
137. Lets LISP like it's 1959
Kristoffer Gronlund

One of my favorite papers in computer science is the original LISP
paper by John McCarthy. Written in 1959, it describes something
mind-bending: The interpreter for a language in the language that it
interprets. If you understand this paper, you understand how
computation works.

A few years ago, I decided to implement the interpreter described in
the paper, and this project turned out to be surprisingly popular. In
this presentation, I'll show how to implement the original LISP
interpreter in C, and together we will marvel at its elegance.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/Lets_LISP_like_its_1959.mp4
138. Writing Viruses for Fun, not Profit
Ben Dechrai

Going viral hasn't always been considered good. Whether you're fighting the common cold, or trying to remove the ILOVEYOU computer worm from your corporate file server, two things are certain: your immune system is based on your gut health, and computers have really poor gut health.

Stopping viruses is hard. The main reason for this is that viruses are really clever. They've evolved over time to escape detection. Each previously detected virus allows the next iteration of the virus to become more resilient. The second reason is that your computer's gut health has to fight every virus, whereas each virus just has to find one immuno-compromised system to survive.

Let's work out how viruses hide. How to they sneak past the checkpoints. How they attach themselves to your system. How they fight detection, and removal. We'll look at aspects such as self-replication, cryptographic obfuscation, and touch on methods of delivery and infection.

Now that you're thinking like a virus writer, you can anticipate which areas of your applications need hardening. Just remember, we're doing it for good, not profit :)

This presentation will feature live demos of writing PHP viruses, and infection of willing targets. The theories apply equally to many languages, so an understanding of PHP is not required.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/Writing_Viruses_for_Fun_not_Profit.mp4
139. Climbing the Summit with Open Source and POWER9
Michael Neuling

In June 2018, the POWER9-based Summit supercomputer benchmarked as the world's fastest. The journey to this milestone started over 4 years ago and has seen the IBM OzLabs team drive the use of Open Source with POWER9.

POWER9 was a huge shift in functionality from previous designs. The new design introduced completely new interrupt controller and memory management architectures, and upgrades to IO, like next-generation PCIE and new acceleration interfaces - NVLink and OpenCAPI.

To take this highly technical, innovative and complex system from early concept through to the top of the supercomputer world required not only bucket loads of code, but organisational and risk management.

In this talk, we'll share our experiences of this journey and show how Open Source is used with POWER9.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/Climbing_the_Summit_with_Open_Source_and_POWER9.mp4
140. Mozilla Project Things Workshop
kathy giori

Come learn about Mozilla’s Project Things initiative. It is an open source implementation aimed at promoting a decentralized, and W3C-standardized, Web of Things framework for managing IoT device data. Mozilla’s implementation puts people first, protecting user privacy and security, while promoting industry interoperability.

Objectives: Attendees will learn how to set up a private IoT gateway, and how to to program MCU hardware by following an online tutorial, that takes advantage of open source “webthing” libraries.

Prerequisites: No prior developer skills are necessary. Bring a laptop (any OS). Attendees will be provided with a developer board that they can program during the workshop, and continue to use later by following an online tutorial. Prototyping hardware is generally low cost, and readily available.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Thursday/Mozilla_Project_Things_Workshop.webm
141. Executable Code Golf: Making Tiny Binaries for Constrained Systems
Nathan Egge

Ever had to rewrite an algorithm or data structure to keep your binary within a certain size? Then you've played executable code golf!

For whole programs, a common practice is to use an executable packer like UPX. However as your binary size gets smaller, the overhead of the decoding stub becomes significant and the compression efficiency of the LZ-based algorithms go down. Better compression can be had using a compressing linker like Crinkler, but this closed source project only supports 32-bit Windows targets. For Linux targets or 64-bit / non-x86 / obsolete hardware there is no good alternative.

The XLINK project is an open-source compressing linker implementing a PAQ-based compression algorithm similar to that in Crinkler. It currently targets older DOS embedded platforms where both disk space and memory are limited and the notoriously long decode times of Crinkler are unacceptable. An experimental 32-bit ELF target is in progress which will bring the same executable compression tools to Linux for use in embedded or IOT applications.

This talk will describe the PAQ compression algorithm in detail and give a short overview of the assembly code for decompression. It will provide an overview of how XLINK works and is able to trade-off start-up time for compression by varying the decoder algorithm, including the use of multiple entropy segments and an alternate lower complexity hashing function. You will learn why applying compression while linking outperforms even the best post-link-stage executable compressors and what extra size-optimization tricks are available at link-time. Finally, we will look at the open research problems in executable compression and other future work like individual function compression for patching existing binaries.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Thursday/Executable_Code_Golf_Making_Tiny_Binaries_for_Constrained_Systems.mp4
142. The Tragedy of systemd
Benno Rice

systemd is, to put it mildly, controversial. As a FreeBSD developer I decided I wanted to know why.

I delved into the history of bootstrap systems, and even the history of UNIX and other contemporary operating systems, to try and work out why something like systemd was seem as necessary, if not desirable. I also tried to work out why so many people found it so upsetting, annoying, or otherwise rage-inducing.

Join me on a journey through the bootstrap process, the history of init, the reasons why change can be scary, and the discovery of a part of your OS you may not even know existed.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Thursday/The_Tragedy_of_systemd.mp4
143. The dark side of the ForSSHe
Hugo Porcher, romain dumont

In February 2014, ESET researchers from Montreal published a report on a group who compromised more than 40,000 Linux servers worldwide since 2011. This research was presented at the LCA 2015 as Operation Windigo. The modus operandi of this campaign consisted mainly in stealing login credentials through an OpenSSH backdoor called Ebury, allowing them to extend their network of compromised servers. Prior to the installation of the backdoor, operators used a recon script to collect a handful of information, including the presence of other OpenSSH backdoors on the system.
In 3 years, we collected hundreds of undocumented samples matching the rules based on the signatures we extracted from the script. This talk will present the analysis we made of these samples, from the most basic ones to advanced ones involving exotic encryption algorithms, anti-logging and diverse methods of exfiltration.
In order to pivot on these findings, we have setup a custom honeypot infrastructure and let the operators behind the backdoors play with it. We will present the checks they make before deploying their malware, how they install it and the lateral movements we observed so far. We will also talk about the new samples we were able to obtain thanks to this poker strike.
Finally, we will give some pointers on preventing this kind of threats and how one can ensure the legitimacy of OpenSSH daemons and clients.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Thursday/The_dark_side_of_the_ForSSHe.mp4
144. Petitboot: Linux in the Bootloader
Sam Mendoza-Jonas

Back in 2014 Jeremy Kerr gave a talk at LCA Perth about a new Linux based bootloader and its potential for server applications. A few years later and that potential has now become a reality as Petitboot is the primary bootloader for every OpenPOWER computer sold today, from the first POWER8 S812L server in 2014 to the POWER9 AC922 server that makes up the "Summit" and "Sierra" supercomputers that took out 1st and 3rd place in the Top500 last June.

Based on popular open source tools like Buildroot and Busybox and using kexec as its booting mechanism gives Petitboot flexibility not only among OpenPOWER vendors and interested developers but makes it just as relevant on x86 and ARM, and has even found adoption outside of the POWER architecture.

In this talk we will cover the Petitboot bootloader; what it is, how it works, the positives and the challenges of delivering an open source bootloader, how it fits in with the current bootloader ecosystem, and where we see Petitboot going in the future.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Thursday/Petitboot_Linux_in_the_Bootloader.mp4
145. Home multimedia and automation systems with GStreamer
Jan Schmidt

Today, people are increasingly familiar with multi-room sound systems that let you listen to your music anywhere in the house.

Building one is easy! But why stop there?

This talk will discuss how the flexibility of the GStreamer multimedia framework helps with implementing a home media system, and the features that make it very simple to develop such applications. It will briefly introduce how data flow handling and synchronisation works in GStreamer, and how various open standards like RTP/RTSP and PTP/NTP can be leveraged to implement these use cases.

Finally the goal is to present an interesting extended use-case: Using the synchronisation primitives in the other direction - to capture and process audio from microphones distributed around a house. Through triangulation and filtering, such as system can provide useful features like speaker isolation and echo-location for recognition and contextualisation of spoken commands.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Thursday/Home_multimedia_and_automation_systems_with_GStreamer.mp4
146. Keynote: A linux.conf.au Story (C1)
Rusty Russell

In which Uncle Rusty tells a nostalgia-drenched tale of the founding of the conference.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/Keynote_A_linuxconfau_Story_C1.mp4
147. Security Vulnerability Mitigations
Joel Sing

Security vulnerabilities allow software to be manipulated in such a way that it misbehaves to the benefit of an attacker - security vulnerability mitigations work to thwart attempts to successfully exploit such a vulnerability. This landscape is continually changing in both the types of attacks and the required mitigations. While the last decade saw buffer overflows as a primary source of attacks, Return Oriented Programming (ROP) and Blind Return Oriented Programming (BROP) attacks pose new threats.

Over the last 20+ years, OpenBSD has essentially been a research and development playground that has designed and implemented such mitigations, in both the kernel and userspace. Many of these mitigations have made their way into other platforms, including Linux, Microsoft Windows, iOS and Android. This talk will look at various long standing mitigations such as W^X and Address Space Layout Randomisation (ASLR), before moving on to more recent developments such as pledge, unveil, KARL, trapsleds, retguard and MAP_STACK.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/Security_Vulnerability_Mitigations.mp4
148. Docker for novices
Alec Clews

An introduction to Docker for developers and testers who have never used it.

Docker is a popular technology but it is often confusing for the novice. This talk makes no assumptions about prior Docker knowledge and takes the student through the basic concepts and terminology. Along the way attendees will learn how to build images, run containers, map ports and create mounts. Finally Docker Compose is introduced.

Please make sure you install Docker **before** the workshop by
following the setup information at:

https://github.com/dockerfornovices/DockerSimpleDemo/wiki/SetUp

Thanks to @bretfisher and @jpetazzo for writing these setup instructions and saving me a lot of time.

If you have problems before the workshop ping me on twitter as @alecthegeek.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Friday/Docker_for_novices.mp4
149. Preventing the IoT Dystopia with Copyleft
Bradley M. Kuhn

Most IoT (The Internet of Things) devices remain under the control of the companies that manufacture them, yielding a plethora of security, privacy and software freedom concerns. Ironically, most such devices include Linux as their base operating system, and Linux's license, GPLv2, mandates the users' rights to modify and upgrade the software. Sadly, due to widespread violations of the GPL, such rights are rarely granted with most IoT devices on the market. This talk explains the political, social, and legal backstory that led to this abysmal situation, and proposes what we must do next to ameliorate the problem.

IoT (The Internet of Things) is a marketing push by device manufacturers seeking to convince the general public to fill their home with interconnected computers embedded inside commonplace contraptions and tools. Proponents ballyhoo the IoT revolution as bringing the ultimate in convenience and informational interconnectivity for everyone.

However, these embedded devices typically remain under the complete control of the manufacturer — not only for their basic functionality — but for safety and security updates as well. In many cases, these devices require Herculean efforts by the home user to modify and upgrade.

Most ironically, however, nearly all these devices run Linux, which is released under a modification-respecting license, the GNU General Public License, version 2 (GPLv2). The GPLv2 uses copyright controls to mandate the users' ability to modify and upgrade the software. Yet, due to widespread GPL violations throughout the industry, rarely do IoT devices come with the freedoms and rights that GPL tries to uphold.

This talk will explain the political, social, and legal ramifications of this abysmal situation. Attendees can expect a full explanation of the history of GPL enforcement, how it has historically defended the rights of hobbyist modifications to home devices, and what processes exist now to continue that fight. In particular, the talk will explain why community-oriented and led GPL compliance efforts are absolutely essential in preventing one of our greatest community-organized technological successes — namely, the development of Linux — from becoming part of a dystopia of corporate control in IoT.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Friday/Preventing_the_IoT_Dystopia_with_Copyleft.mp4
150. Cache Pathology Report of Linux System Calls
Xi Yang

Linux system calls have complex and large instruction footprints leading to poor cache utilization on modern CPUs. The poor locality has a strong impact on the performance of both the kernel and applications. However, understanding kernel cache behavior is not easy because system calls are fast and run in the context of the user process.

This talk presents a high frequency profiler called SHIM-PT that can help developers to understand the relationship between the code and kernel cache usage by correlating CPU performance counters with instruction flows of system calls on modern CPUs.

SHIM-PT uses the SHIM profiler to record micro-architecture behavior by sampling performance counters at a high frequency. At the same time, it records instruction traces of system calls with the Simple-PT tracer. Then SHIM-PT correlates the two signals and reports the cache usage.

With Kafka as the workload, we show the importance of kernel performance, the cache usage of system calls and root causes of poor cache locality.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Friday/Instruction_Cache_Pathology_Report_of_Linux_System_Calls.mp4
151. Growing TypeScript and Rust
Jonathan Turner

In this talk, I'll cover how the TypeScript project grew from a small project to a popular web tool, and some of the bumps along the way. I'll also compare this with how Rust has changed and adapted since its 1.0 release.

Lastly, I'll talk about how Rust's collaborative design works and how it helps to shape Rust's direction, and how other open source projects may be able to use similar techniques.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Friday/Growing_TypeScript_and_Rust.mp4
152. Multiple Birds with One Linux, IoT in the Automotive Space
Malini Bhandaru

The OBD-II [1] interface on automobiles today provides access to a rich set of real time vehicle drive data using a pluggable device [2, 3], such as speed, acceleration, braking, GPS co-ordinates, miles driven, fuel consumption, part wear and tear, just to name a few. Imagine what you can do for fun or profit, possibly launch a service to locate your car in a large parking lot, to track your, nay teenager’s, driving habits, help city planning make driving safer, deploy a driving-based insurance discount program, manage a fleet of vehicles, or provide consumer report style feedback/assessment on early stage autonomous vehicles such as number of times and circumstances under which human intervention was necessary.

Let us take a closer look at three classes of applications requiring different data handling, both with respect to privacy and volume, and how we might support them. Consider for the first application, Driver-Profile, an insurance style application, where the aggregation service in the cloud requires tracking vehicle-ID, driver-ID, miles driven, speed, acceleration, hard breaking, and areas driven among other things. A second application, Smart-City, that wants to identify traffic bottlenecks and danger zones in various city limits, identified by regions where a vehicle crawls or the driver needed to slam the brakes. For the third application, Car-Profile, the goal is to identify which cars, manufacturer plus model, is involved in the most speeding incidences. Within the above contexts we demonstrate data extraction, manipulation (masking, dropping, classifying), and transmission (periodically or in aggregate) to various end-points. We shall implement these in the car, aka edge, using the Function-as-a-Service [4] construct. At the data center, based on the service, additional data sources will be combined to obtain the desired insights.

In this talk we bring Automotive IoT to the forefront, demonstrating how Linux on the device/ edge, along intermediate points up into the data center/cloud work together to create a platform to deliver new services to enrich our lives. In true open source style, we shall share the code, to jump start further explorations.

References:
1. https://en.wikipedia.org/wiki/On-board_diagnostics
2. https://www.moj.io
3. http://zubie.com
4. https://www.openfaas.com/

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Friday/Multiple_Birds_with_One_Linux_IoT_in_the_Automotive_Space.mp4
153. Does making the kernel harder make making the kernel harder?
Casey Schaufler

The Linux Kernel Hardening Project is making significant strides in reducing vulnerabilities and in increasing the effort required to exploit vulnerabilities that remain. Much of what has been implemented is obviously valuable, but sometimes the benefit is more subtle. How does the introduction of refcount_t make the kernel more secure, and by how much? What value is there in removing variable length arrays? Casey Schaufler, a (really) long time kernel developer will explain why some of these changes provide significantly greater value than might be apparent to the casual observer. He will discuss the cost of kernel hardening in terms of development overhead, code churn and performance.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Friday/Does_making_the_kernel_harder_make_making_the_kernel_harder.mp4
154. Clockwork and its tools – Open Source Software to make things more easily
Mike O'Connor

Clockwork is a programming tool designed to make programming things easier. It provides a simple way to describe the parts of a complicated system and it comes with tools to help get the model right and present information and controls in a user-friendly way. Clockwork programs are interconnected parts, called 'machines' that monitor each other and make sure the whole system performs as required.
In our presentation, we will show examples of programming `things` and talk about what to do when the programming gets tough. We start with some simple programs that read data from a sensor and use that data to control a small device while also providing an IoT interface to monitor the process. We show these programs using common C/Python tools and also demonstrate how to do the same things with our Clockwork language and tools.
For some years we have been building a set of open source tools for industrial control, based around a language we call Clockwork. It is now possible to compile Clockwork code so it can run on a broad range of devices, from tiny 8-bit Atmel-based Arduinos, small Espressif ESP32 devices, to Linux hardware such as the Beaglebone black. This means that it is now much easier to go a lot further when programming things, without needing to worry too much about writing time-consuming and often quite involved thread stuff.
The secret to keeping things simple is to make the components independent so they can run along happily without concern for other parts of the system. In Clockwork, this is done by describing models of the system we want to control or monitor in terms of its states (e.g. hot, cold, on, off, rising, falling, and so on). We think that the model-building approach makes it easier for programmers to achieve more, especially where the system being controlled involves many interacting parts that need to be controlled in parallel and in real time. Accomplished programmers will enjoy programming with the Clockwork tools especially for complex systems and new programmers will enjoy being able to get further with less debugger time. We think that its main benefit is simplifying the process of building complete systems, enabling construction by describing what a system should do rather than how it must do it.
There are many exciting features about the clockwork language, including: internal or external monitoring of state changes, comprehensive debugging that tracks the state components are in and how they got there, and the ability to display everything on a webpage -and don't we all simply love that!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/Clockwork_and_its_tools_Open_Source_Software_to_make_things_more_easily.mp4
155. Making the P.A.I.N C.A.V.E
Stephen Hemminger

Pain cave is what Triathletes and cyclists call their indoor training setup. Programmable Ant+ Input Network for Community Alternative Velo Environment (PAIN CAVE) is my project to take fitness input (Ant+) and display the data in creative ways. As an avid indoor cyclist, I wanted a way to have lights and displays controlled by the level of effort. Most of the traditional fitness applications such as Garmin, Strava, and Zwift are closed source and PC centric with no ability for customization or creativity. PAIN CAVE is an alternative platform using Linux on Rasberry Pi and USB sensors to control LEDs and panels. This talk is about the process of making a project like this from the ground up.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Friday/Making_the_PAIN_CAVE.mp4
156. Facebook, Dynamite, Uber, Bombs, and You.
Lana Brindley

Consider these two cases: Volkswagen was caught out having written software code that allowed their cars to cheat emissions tests. Uber also developed software (called 'greyball') which allowed them to cheat law enforcement officials trying to crack down on ride-sharing. The difference is that Volkswagen software engineers went to jail, and Uber software engineers didn't. Why? Because one is a car company, and one is a software company.

Most industries have had what we might call an "oh no" moment. It's those moments that encourage industries to become better regulated, in order to prevent further disasters. The IT industry has had many moments that could be considered consequential enough to encourage better regulation, but the changes have never been made. Because the industry has avoided effective regulation for so long, it is possible that we are hurtling towards a disaster of epic proportions, one that we haven't even managed to conceive of yet.

In this talk, I will go through some historical examples of disasters leading to regulation in other industries, and the measures that were put into place to mitigate the problem. I will also address some of the major moments from the IT industry that should have prompted regulation, and haven't. Finally, I will discuss ways that IT professionals can blow the whistle on potential disasters before they happen ... without losing your job!

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Friday/facebook_dynamite_uber_bombs_you.mp4
157. Web Security 2019
James Bromberger

20 years of web cryptography, and its amazing how frequently its configured sub-optimally. We've had numerous encryption algorithms, digests, protocols come, and should have GONE, but everyone has just left them on. Its time to shut out the legacy browser. The vast majority of the worlds browser install base now auto-updates, and with strict (and prescriptive) compliance in force, we get to drop the bloat form the past. In this talk we'll cover the current TRANSITIONS we're going through from a web admins perspective: TLS, Cipher Suites, HTTP Security Headers, CAs, the move to an encrypted-by-default web, and more.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Friday/Web_Security_2019.mp4
158. Production ready Kubernetes in OpenStack public clouds
Feilong Wang, Xingchao Yu

Platform services have came a long way. Not only they are getting more popular, but they are also driving true multi-cloud interoperability. The combination of OpenStack and Kubernetes is becoming a standard option to allow users to benefit from both virtual machines and containers for their cloud-native applications.

In this presentation we will share Catalyst’s public cloud journey in building a production ready managed Kubernetes service on top of OpenStack. The following items will be covered:

* Network isolation with K8s network policy
* Persistent volume integrated with OpenStack Cinder
* Loadbalancer and Ingress integrated with Octavia
* K8s Keystone auth integration
* Multi master deployment
* Conformance (Sonobuoy) verification/testing
* Automation of K8s rolling upgrades

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/Production_ready_Kubernetes_in_OpenStack_public_clouds.mp4
159. Building reproducible computing environments: a workshop for non-experts
Aleksandra Pawlik

Dependency hell is ubiquitous in the world of software for research. This affects research transparency and reproducibility. As a part of Stencila project we are developing a tool, Dockter, which makes it easier for researchers to create Docker images for their research projects. Dockter also generates a JSON file with information about the software environment (based on CodeMeta and Schema.org) allowing for further processing and enabling interoperability with other tools.
During this hands-on (bring your laptops!) tutorial you will work through generating a sample interactive and reproducible research report.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a3/Friday/Reproducible_research_in_spreadsheets_with_Stencila.mp4
160. Making C Less Dangerous in the Linux kernel
Kees Cook

With the Linux kernel written in C, it comes with some worrisome baggage, "undefined" behaviors, and other weaknesses that lead to security flaws and vulnerable infrastructure. Some of these weaknesses related to the design of chipsets and how close C is to machine code, but others are less specific.

This presentation will explore the areas where the kernel is changing the C standard, defining undefined behaviors, or otherwise reorganizing things to make C itself less of a hazard.

Specifically this will cover removing (and enforcing the lack of) Variable Length Arrays in kernel code, forcing all stack variables to be initialized with a GCC plugin, performing implicit bounds checking with overloaded builtins, handling arithmetic overflows safely, and protecting forward (call) and reverse (return) indirect function calls with CFI under Clang.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Friday/Making_C_Less_Dangerous_in_the_Linux_kernel.mp4
161. OpenLI: Lawful Intercept Without the Massive Price Tag
Shane Alcock

Lawful intercept (LI) obligations for Internet service providers have changed significantly in the past few years. Whereas law enforcement agencies were previously willing to accept a simple pcap trace of customer traffic (typically delivered some number of hours or days of delay) for the requested time period as a valid intercept, new standards for LI, such as the ETSI LI standards, are much more onerous for operators to comply with. Specifically, intercepted traffic must be delivered to the agencies in real time, encapsulated within LI-specific headers and delivered alongside additional meta-data records that describe how and when the target was interacting with the operator's infrastructure (i.e. RADIUS servers, SIP servers, etc.).

In New Zealand, all Internet service providers that have at least 4000 subscribers must be capable of delivering an ETSI-compliant intercept (live-streamed) upon receipt of a warrant from a law enforcement agency. Many hardware vendors offer licenses that will enable LI capabilities in their devices, but the cost of these licenses is extremely high. This creates a problem for smaller network operators: how can they meet their LI obligations without bankrupting themselves on vendor licenses?

The OpenLI project is a collaboration between the WAND Network Research Group at the University of Waikato and a group of New Zealand network operators aimed at providing an alternative (and much cheaper) way for operators to meet their lawful intercept requirements as defined in New Zealand law. WAND provides the experience and programming expertise to develop an ETSI-compliant software solution that can be used by the operators to meet their LI obligations. In turn, the operators each contribute a relatively small sum of money to cover the cost of the programmer's time and provide access to realistic deployment environments and traffic workloads for testing. The eventual finished software will be released as open-source under a GPL license.

This talk will cover a number of relevant topics, including:
* The ETSI LI standards and why pcaps aren't good enough anymore.
* The LI landscape in New Zealand specifically and how it led to OpenLI being started.
* Why hasn't anyone tried to solve LI with OSS before?
* Overview of other OSS that OpenLI is built upon.
* Design and structure of the OpenLI software.
* Interesting anecdotes about tricky problems we've had so far and how we've solved them.
* Where the project is at right now.
* What you can do to help out, if you are that way inclined.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Friday/OpenLI_Lawful_Intercept_Without_the_Massive_Price_Tag.mp4
162. Open Source Magnetic Resonance Imaging: From the Community to the Community.
Ruben Pellicer Guridi

Motivation
MRI is a powerful medical device beyond the reach of many patients throughout the world. Open source imaging initiative (OSI²) aims to address this issue collaboratively by facilitating the sharing of research around MRI technology and building an affordable open source MRI scanner. Here we present the roadmap of OSI² which extends into six different areas:
1. Open Source Hardware and Software Development
2. Guidelines for Open Source Research and Development
3. Community Building
4. Quality, Reliability and Safety
5. Education
6. Businesses and Distribution

Open Source Hardware and Software Development
Similar to OS complex software projects, our hardware development follows a modular approach. This will allow independent developments, as well as reproducible and exchangeable components. We are developing a complete MRI prototype for the extremities. Our efforts are, however, not limited to this initial system. We encourage the community to develop and exchange alternative approaches.

Guidelines for Open Source Research and Development
Transparency should be a must in science. Providing open source software and hardware documentation along with a scientific publication accelerates the reproducibility of scientific advancements, facilitates the validation of findings, and rewards authors with visibility. We encourage researchers to publish in journals that promote OS software/hardware publications.

Community Building
We are implementing open communication channels for software/hardware and general discussions to stimulate participation and to collaboratively shape and move towards our vision.

Quality, Reliability and Safety
Quality, reliability and safety of medical devices is typically assured through the oversight of government-based organisations. We want to create guidelines that will allow a smooth transition from research prototypes to medical devices. These guidelines will also help developers in countries, where the requirements for device safety may be arbitrary or nonexistent. We are collaborating with OpenQRS in a long-term vision to implement open data systems to inform the users and the public about the quality, reliability and safety of healthcare devices to ensure and improve patient safety.

Education
Education stands on transparency. Providing the widest possible access to documentation, manuals, data, and source code fosters the training of users and developers. We highly encourage developers to go the extra mile and document their work openly, which will provide easy global access to knowledge for students, researchers, and developers.

Businesses and Distribution
Although OSI² is a not-for-profit movement, business partners will be important to boost global access to MRI systems and ensure their quality. OS R&D of MRI hardware has the potential to lower investment/service costs, create local markets with stable low prices, and encourage device customisation.

Conclusion
Through transparent collaboration we hope to improve global access to affordable and high-quality MRI devices, which could lay the groundwork for development of other medical devices. Please visit www.opensourceimaging.org or contact us at info@opensourceimaging.org to contribute and help us make this vision a reality.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Friday/Open_Source_Magnetic_Resonance_Imaging_From_the_Community_to_the_Community.mp4
163. 1space: Sharing data across clouds
John Dickinson

1space allows you to store data in different storage systems and access them as part of one unified namespace. It can also move data from one location to another based with a rules-based system. These two features together gives users the ability to have data where they need it without needing to rewrite apps to account for where data is right now. 1space supports OpenStack Swift and S3 APIs and currently can be used with OpenStack Swift, AWS S3, Google Cloud Storage, or another S3-clone.

This talk with introduce the 1space project and describe how it is used in production today. We'll go into detail about how it works and what's coming next in the project.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Friday/1space_Sharing_data_across_clouds.mp4
164. Apathy and Arsenic: a Victorian Era lesson on fighting the surveillance state
Lilly Ryan

What does expensive Victorian era wallpaper have in common with a Cambridge Analytica Facebook quiz?

Why is the GDPR like a trip to a seaside resort?

How could a cryptoparty have anything to do with a rare book in a library in Michigan?

Lilly Ryan - historian, privacy advocate, and penetration tester - walks you through a two hundred year old method for fighting the surveillance state, based on the advocacy led by 19th century scientists to abolish the domestic use of arsenic. You will learn about the tireless efforts used by anti-arsenic activists to change the public perception of arsenic, Cory Doctorow's theory of Peak Indifference, the lives ruined by data breaches, and how to sustain the recent public shift from "I have nothing to hide" to "I value my privacy".

This session will offer tips for developers, security professionals, and other interested folks on how to help everyday people have more power over their own information and how to sustain hope for the future when we've been aware of the solutions for years.

Come along and take in stories of murder, mismanagement, and mendacity, and learn how to keep up the fight against mass surveillance now that the tide is turning.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a1/Friday/Apathy_and_Arsenic_a_Victorian_Era_lesson_on_fighting_the_surveillance_state.mp4
165. STM32 Development Boards (literally) Falling From The Sky
Mark Jessop, Michael Wheeler

Radiosondes are scientific instruments carried aloft under weather balloons to measure characteristics of the upper atmosphere. Thousands of these devices are launched around the world on a daily basis, and are generally left to litter the countryside wherever they land.

Using a low cost software-defined radio, a Raspberry Pi, and all open-source software, it is possible to decode signals from these devices. You can then track their flight path, collect the weather data they transmit, and even recover and repurpose them!

This talk will cover the development and worldwide use of the radiosonde_auto_rx project, and how we have been re-purposing Vaisala RS41 radiosondes for use on our own high-altitude balloon flights.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/STM32_Development_Boards_literally_Falling_From_The_Sky.mp4
166. Maintaining the Unmaintainable: Picking up the Baton of a Secure Kernel Patchset
Matthew Ruffell

The world of kernel security forever changed on April 26th 2017, when Open Source Security Inc published a press release announcing that they are no longer making their grsecurity kernel patchset available to the public, and that they are "handing over future maintenance of grsecurity test patches to the community". Citing their wishes for newcomers to experiment with new ideas, and that the future will be shaped by the next generation, they challenged the world to continue maintenance on grsecurity themselves. Left with little more than the previous patch to 4.9.24, and the knowledge that 4.9 will receive back ported fixes from upstream for two years, it was clear that there were large shoes to fill.

At the time, I was building my distro, Dapper Linux, and one of its key value propositions is running a grsec kernel out of the box. Feeling left high and dry, and unwilling to give up on the technological advancements that the patchset provides, I decided to learn kernel development, and attempt to maintain the patchset as a complete kernel newbie.

In this talk, we will have a look at the internals of the patchset, and what features are provided, slightly touch on the politics surrounding the patchset (and epic flamewars on the kernel-hardening list). We will also see what I have done to keep the patchset alive, and my attempts to forward port the patchset to newer major kernel versions, as well as the typical maintenance for 4.9 LTS.

We will also see how a kernel newbie became the sole maintainer of the patchset in its entirety, and the roadblocks that have arisen that have caused far more experienced developers to give up. Finally, we will talk about what the future holds, once support for 4.9 LTS ends in Jan 2020.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c3/Friday/Maintaining_the_Unmaintainable_Picking_up_the_Baton_of_a_Secure_Kernel_Patchset.mp4
167. Who pays the piper? The caller of the tune.
Don Christie

The question is no longer "how does free and open source software make money?" That case was proven long ago by many individuals and companies. Produce and support something people love and money will follow.

Of more interest and perhaps importance for our communities and future is the question - who is paying who for what?

What are the models of making sure that the contributors to FOSS: conference organisers; artists; testers; documenters; security experts and even developers are able to survive and thrive not simply doing what the love, but making the world a better place. Financial models matter.

I, Don Christie, am Managing Director of successful Kiwi free and open source company Catalyst IT. The last 21 years has seen Catalyst grow from a Wellington start up to a multinational group of businesses with a thriving presence across NZ, Australia and the UK. Our company exists for these reasons: https://www.catalyst.net.nz/blog/7-themes-catalyst

Over these 21 years we have seen, participated in and led free software projects and ventures. We have seen financial models that promote, strengthen and enhance our communities and others that have not. We have tried different versions ourselves with varying degrees of "success", however that might be defined.

This talk will focus on pure play FOSS (as defined by the OSI) based models and licensing regimes. It will have examples, bias and will challenge both Catalyst's approach to contributing to FOSS and maybe many in the audience as well.

Most of all, the talk will be fun. Because life is too short for pain.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Friday/Who_pays_the_piper_The_caller_of_the_tune.mp4
168. But Mummy I don't want to use CUDA - Open source GPU compute
Dave Airlie

CUDA has become the defacto standard for GPU compute in most fields. AI and Machine Learning via projects like tensorflow are all targeting CUDA as their runtime. CUDA however as one major flaw, it's closed source and requires closed source drivers.

This talk will explore the current state of non-CUDA compute stacks, concentrating on the OpenCL, SPIR-V and SYCL projects from Khronos, but also touching on Vulkan compute and other possibilities.

It will discuss the some possible problems with AMD ROCm and Intel OpenCL drivers from a Linux platform point of view and try to scope out what a vendor-neutral Linux focused compute stack might look like that has maximal code sharing across vendors and doesn't require shipping various vendor forks of LLVM.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/a2/Friday/But_Mummy_I_dont_want_to_use_CUDA_Open_source_GPU_compute.mp4
169. Digital Future Aotearoa report back from the Children's Program

Volunteers from Digital Future Aotearoa
(https://www.digitalfutureaotearoa.nz/) ran a week-long programme for
children 6+ during linux.conf.au 2019.

The children present the projects they've been working on all week,
including a fire-detection device, a rubbish eating turtle robot, an
anti-bullying button and an irrigation system.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/Digital_Future_Aotearoa_report_back_from_the_Childrens_Program.webm
170. Conference Lightning Talks (Friday)

Linux.conf.au 2019 lightning talks.

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/lightning_talks.mp4
171. Conclusion - LCA 2019

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c1/Friday/conclusion_lca_2019.webm
172. Lightning Talks - C2, Monday
Various

(Needs description.)

Video: http://mirror.linux.org.au/pub/linux.conf.au/2019/c2/Friday/lightning_talks_c2.webm

Location
--------
dash

About the group
---------------
linux.conf.au is a conference about the Linux operating system, and all aspects of the thriving ecosystem of Free and Open Source Software that has grown up around it. Run since 1999, in a different Australian or New Zealand city each year, by a team of local volunteers, LCA invites more than 500 people to learn from the people who shape the future of Open Source. For more information on the conference see https://linux.conf.au/