pre-release: linux.conf.au meeting announcement

Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.

Subject: 
ANN: linux.conf.au at Great Hall CB01.05.009 Mon January 22, 9p


linux.conf.au
=========================
When: 9 AM Monday January 22, 2018
Where: Great Hall CB01.05.009
This talk was given at Linux.conf.au 2018 (LCA2018) which was held on 22-26 January 2018 in Sydney Australia.
http://linux.conf.au

Topics
------
1. Conference Opening
Jack Skinner, Bruce Crawley, James Polley
tags: Kernel Miniconf
Welcome to linux.conf.au 2018!
 recording release: yes license: CC BY  

2. Introductions


(Needs description.) 
 recording release: no  

3. Miniconf Intro
Andrew Donnellan
tags: Kernel Miniconf
Miniconf welcome and introduction
 recording release: yes license: CC BY  

4. You Can't Unit Test C, Right?
Benno Rice
tags: Developers Developers Miniconf!
Testing is a wonderful thing. Code with good tests is so much easier to work with and change due to the comfort the tests provide that you haven't broken anything you didn't expect to break.

C can be a tricky language to work in. It compiles to static code. It's incredibly low-level compared to many of the languages people use these days. It also comes with a delightfully bewildering and wide array of ways to very effectively shoot yourself in the foot. On top of that the POSIX API implementations C code often relies on don't lend themselves to easy testing, especially of unhappy paths. Which means that while we should absolutely be testing our C code it should be really hard to unit test, right?

Join me for a quick overview of the ways in which C can be unit tested, including ways to push around the POSIX APIs, and how you too can increase your C code's level of comfort.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/You_Cant_Unit_Test_C_Right.webm 
5. Disruptive DNA sequencing
Martin Smith
tags: Open Source and Bioinformatics
Disruptive DNA sequencing
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/Disruptive_DNA_sequencing.webm 
6. Opening


(Needs description.) 
 recording release: no  

7. LoliBot Assembly Workshop (registration required to participate, spectators also welcome)


(Needs description.) 
 recording release: no  

8. Look out for what's in the security pipeline
Casey Schaufler
tags: Kernel Miniconf
Rejoice, for the days when your only choice for enhanced security in the Linux kernel was SELinux are coming to an end. Learn how the AppArmor and Smack security modules are filling needs that SELinux isn't so well suited for. Learn about new security modules like Landlock that are taking 21st century approaches to modern security concerns. Find out about a set of smaller security modules that do all sorts of interesting things, from general process tags to strengthening changing chroot. With all that to think about, you'll be exposed to the efforts to combine and composer security modules. The talk wouldn't be complete without relating all this to containers and virtualization. Nor would it be fair to leave out advances in the Audit and Capabilities features. Finally no discussion of Linux kernel security would be complete without something about efforts to harden it and fix exploitable flaws.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Look_out_for_whats_in_the_security_pipeline.webm 
9. Open Sourcing History: Using Historians in Games Development
Claire Manning
tags: LCA Games Miniconf: Games and FOSS
When you’re working in a game that is open source, you’re likely to be working with people of various ethnicities, races and genders, and it’s important to keep their backgrounds in mind. This is particularly important for historical games, where avoiding stereotypes and aiming for authenticity is crucial. Aiming for accuracy not only makes the game more authentic, but also helps develop and expand the player’s understanding of history. 

We all know that history can complement video games by creating an interesting setting that the audience is usually at least vaguely familiar with. When you set a game within a historical setting, you get a pre-built rich environment, and you also save time on explaining the player’s surroundings. 

This talk will be looking at the Assassins Creed franchise and Horizon: Zero Dawn, which both reached out to historians and anthropologists. Both games have extremely different settings, and worked in very different ways to effectively create a feel of authenticity. I will further be discussing how historical and anthropological experts are more than happy to share their knowledge for the sake of historical accuracy, with many believing it to be the future of historical education.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Open_Sourcing_History_Using_Historians_in_Games_Development.webm 
10. Brainstorm the Agenda


(Needs description.) 
 recording release: no  

11. The not so secret source of bioinformatics
James Ferguson
tags: Open Source and Bioinformatics
The not so secret source of bioinformatics
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/The_not_so_secret_source_of_bioinformatics.webm 
12. Torres Strait Virtual Reality
Rhett Loban
tags: LCA Games Miniconf: Games and FOSS
Torres Strait Virtual Reality is an educational virtual reality game that aims to teach about Torres Strait Islander culture and knowledge. The game has been implemented and showcased in several university courses and events at UNSW. The presentation will touch on the project and its current outcomes, and also how the FOSS philosophy has impacted on the project and developer generally.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/linux.conf.au/2018/medium/Monday/Making_your_first_game_in_Twine.mp4 
13. Understanding git - even the scary parts
Anwesha Chatterjee
tags: Developers Developers Miniconf!
Git is by far the most popular version control system used by developers today. However, some aspects of Git can be hard to grasp as a new developer. This talk is aimed at Git users and developers who would like to understand how Git works on a conceptual level, so they can use Git to its full potential without fear. Topics covered in this talk are:
* A high level view of how Git’s storage works
* What is a branch
* Git merge and Git rebase - and when to use (and not use) them
* Git Vs. repository management services like Gitlab and Github
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Understanding_git_even_the_scary_parts.webm 
14. Developing a game for the Macintosh Plus in 2017
Josh Deprez
tags: LCA Games Miniconf: Games and FOSS
This is a talk about Retro68, a framework for compiling software targeting Motorola 68k machines such as the early Macintoshes, and how I used it to make a simple game this year.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Developing_a_game_for_the_Macintosh_Plus_in_2017.webm 
15. Open Source Bioinformatics with R and RShiny
Goknur Giner
tags: Open Source and Bioinformatics
Open Source Bioinformatics with R and RShiny
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/Open_Source_Bioinformatics_with_R_and_RShiny.webm 
16. Large Memory Management issues: Performance, Fragmentation, Movable objects and Huge Page overhead.
Christopher Lameter
tags: Kernel Miniconf
Memory management with larger memory sizes of around a couple of
terabyte leads to a number of issues that make life hard. This talk is
a look at the issues and at the work in progress on these issues.

First, huge pages are not supported for the page cache which leads to
numerous performance issues. It begins with the long time it takes to
just copy a file of a few gigs in size (minor compared to the size of
the memory in the system of a few terabytes after all...) to the
performance problems when accessing large amounts of 4k pages from a
memory mapped file. Since huge pages are not supported TLB trashing
often becomes an issue. Devices have issues writing large blocks of
data to disk due to large scatter gather lists having to be processed
in memory. Reclaim becomes slow since the system is literally churning
through billions of 4k page to figure out which ones to evict.

Second, huge pages cause a memory overhead that surprises users. The
kernel manages 4k chunks of the huge page in many cases and needs to
have metadata structures for each 4k page. Other metadata also exists.
This results in gigabytes of memory just not being present. The user
bought a system with a lot of memory but the Linux just cannot use it.

Third, fragmentation becomes an issue in particular if huge pages and
4k pages are frequently allocated and freed (like we have to because
the page cache does not support 4k after all).  So over time systems
have to be rebooted to allow the allocation of huge pages. Huge pages
are actually only a small problem because devices on large systems
often want to allocate large contiguous buffers for I/O (like
specialized networking devices using RDMA).
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Large_Memory_Management_issues_Performance_Fragmentation_Movable_objects_and_Huge_Page_overhead.webm 
17. Source Code Generation: How I Learned to Stop Worrying and Love the Boilerplate
Daniel Phillips
tags: Developers Developers Miniconf!
Automatic source code generation might seem like a hack to most developers, but it doesn't have to be this way. When used effectively as part of a software project's development and build processes, code generation can encourage good practices, reduce bugs, and save valuable developer time by eliminating the need to write boilerplate code by hand. This talk will look at a few use cases for automatic source code generation, and discuss the high-level design principles involved in using, or even rolling your own source code generator.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Source_Code_Generation_How_I_Learned_to_Stop_Worrying_and_Love_the_Boilerplate.webm 
18. Summaries of the topics


(Needs description.) 
 recording release: no  

19. Making noise on a zero budget: the joys of game audio.
Jody Toomey
tags: LCA Games Miniconf: Games and FOSS
Audio is one of the most engaging aspects of game design that can either bring the player in to a really engaging experience or ruin all of it.
This talk will look at some of the principles of game audio while relating the workflow process to the free and open source philosophy.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Making_noise_on_a_zero_budget_the_joys_of_game_audio.webm 
20. HealthHack
Liz gilleran
tags: Open Source and Bioinformatics
HealthHack
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/HealthHack.webm 
21. In from the cold: Finally making Linux and .NET get along
Alistair Chapman
tags: Developers Developers Miniconf!
.NET Core has finally arrived and is soon to hit 2.0, bringing vastly improved Linux compatibility and support for more distributions. Has the promised age of truly cross-platform .NET and real Linux support finally come?

This talk will be drawing on years of experience working with .NET technologies on Linux platforms (including Mono), as well as working with the latest .NET Core stack. In this session, I will be covering a brief history of .NET on Linux bringing us to today’s new cross-platform stack, including how to get started with .NET Core on Linux platforms.

I’ll also be looking at how you can integrate .NET apps and services into Linux environments, including simple deployment, testing and packaging strategies, as well as looking at how to integrate .NET with common Linux services including systemd, dbus and GTK. Finally, I will be showing how to build a complete pipeline to build, deliver and run .NET apps entirely on Linux.

This talk will start with the high-level essentials of working with .NET technologies on Linux while also covering the deeper technical details so is perfect for any level of Linux user, but will be especially useful to .NET users.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/In_from_the_cold_Finally_making_Linux_and_NET_get_along.webm 
22. Turning stories into software
Donna Benjamin
tags: Developers Developers Miniconf!
The user story sits at the centre of most agile development methodologies. 

But what makes a good story? and where do stories come from? What do we do with them once they've been estimated, prioritised, re-sized and broken down? How can we maintain our sense of the big picture when it's broken down into tiny puzzle pieces? How does that help us build good products? 

This talk puts the focus on the "user" telling the story to understand their requirements for the product. It then turns back to the team to look at how we hear and discuss those stories in order to bring them to life to build the product, and build it right.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Turning_stories_into_software.webm 
23. Design of the LoliBot hardware
John Spencer
tags: Open Hardware Miniconf
An overview of the design of the LoliBot hardware.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Micropython_on_the_LoliBot.webm 
24. Using Mutagenesis to Understand Protein Function
Alan Rubin
tags: Open Source and Bioinformatics
Using Mutagenesis to Understand Protein Function
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/Using_Mutagenesis_to_Understand_Protein_Function.webm 
25. Group discussions


(Needs description.) 
 recording release: no  

26. Status of Mainline Linux on AmLogic SoCs
Neil Armstrong
tags: Kernel Miniconf
Inexpensive set-top boxes are everywhere and many of them are powered by AmLogic SoCs. These chips provide 4K H.265/VP9 video decoding and have fully open source Linux kernel and U-boot releases.
Unfortunately most of the products based on these devices are running an ancient 3.10 Android kernel. Thankfully AmLogic has put a priority on supporting their chips in the mainline Linux kernel.
Neil will present the challenges and benefits to pushing support for these SoCs upstream, as well as the overall hardware architecture in order to understand the Linux upstreaming decisions and constraints.
Neil will also detail the future development plans aiming to offer a complete experience running an Upstream Linux kernel.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Status_of_Mainline_Linux_on_AmLogic_SoCs.webm 
27. Changing the world through (fan-)fiction
Paul '@pjf' Fenwick
tags: LCA Games Miniconf: Games and FOSS
Fiction exists to entertain its audience, but it is also fundamental to shaping the evolution of society itself. Much fiction is based around the concept of new ideas; movies like The Matrix had us consider whether our world was a simulation, and the contemporary Westworld has sparked many a discussion about consciousness and personhood.

Yet fiction gives us something even more compelling, and more powerful, than merely exploring new ideas; it gives us stories about how to live our lives. Popular fiction provides society with scripts on what to expect, how to act, what's important in life, how to form relationships, what to aspire to, and commentary and scaffolding on almost every other part of our lives.

Intertwined with this has been the long, long tradition of writing fan-fiction; using an existing story or world to expand, explore, or re-invent. Disney solidly highlighted the power of fan-fiction by creating animated films that re-interpret fairy tales that were already familiar to audiences. Modern fan-fiction—while sometimes occupying a niche role—has taken this even further; and is now a powerful vehicle for the exploration of new concepts and ways of living our lives.

The creation of fan content also provides an important entry-point for many people—especially young women—into technical skills including programming, front-end development, media editing, and content management. We'll examine how current attitudes towards fan-content are directly damaging to diversity in the tech industry, and society as a whole.

A reading list and further resources will be provided for those wishing to learn more.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Changing_the_world_through_fanfiction.webm 
28. Next Generation Config Mgmt: Resources
James Shubin
tags: Developers Developers Miniconf!
Mgmt is a next gen config management tool that takes a fresh look at automation.

The main design features of the tool include:
* Parallel execution
* Event driven mechanism
* Distributed architecture
And a:
* Declarative, Functional, Reactive programming language.

The tool has two main parts: the engine, and the language.
This presentation will demo both and include many interactive examples showing you how to build reactive, autonomous, real-time systems.
We'll focus on how to get developers involved so that they can build a resource or a function to fit their specific needs!
Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Next_Generation_Config_Mgmt_Resources.webm 
29. Namespacing in SELinux
James Morris
tags: Kernel Miniconf
Linux kernel namespaces provide isolated views of kernel resources, such as networking, IPC, and filesystem mounts.  Combined with cgroups, namespaces form the basis of Linux containers, a form of lightweight virtualization which shares a single kernel image. 

While namespacing support has been implemented for several key kernel resources, security components of the kernel such as LSMs (Linux Security Modules) currently lack namespacing support.  This presents many challenges for those wishing to deploy full-system containers, which appear to the user to be operating system instances, but which are in fact subject to global security mechanisms and policies.

In this talk, I'll discuss the work in progress to extend Linux kernel namespacing support to SELinux, to allow full-system containers to load their own individual security policies into an virtualized instance of the SELinux kernel mechanism.  This work is based on prototype patches posted by the NSA a few months ago,  which I've been extending to cover file labeling support as one of several current TODO items.

We'll discuss how the core SELinux components have been virtualized, the namespacing of xattr-based inode security labels, and future challenges for this project.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Namespacing_in_SELinux.webm 
30. Micropython on the LoliBot
Andy Gelme
tags: Open Hardware Miniconf
Micropython on the LoliBot
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/TBA_4.webm 
31. Augmenting Reality with Open Source
Eloise Ducky
tags: LCA Games Miniconf: Games and FOSS
Wanna make some cool Augmented Reality (AR) games? Can't afford commercial AR libraries or just want to use open source because you're cool like that? Well this talk is here for you!
Come hear about some great open source resources for making applications with AR, as well as some design tips about how not to make AR just another gimmick.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Augmenting_Reality_with_Open_Source.webm 
32. Stemformatics Architecture
isha nagpal
tags: Open Source and Bioinformatics
Stemformatics is a web based pocket dictionary for stem cell researchers. Researchers can quickly and easily visualise their datasets in Stemformatics. They can benchmark their datasets against 350+ high quality, manually curated datasets. They can also use Stemformatics to look across these datasets to find interesting biological patterns.

Following are components in Stemformatics ecosystem :

Pipelines (to process data across different platforms)
Data Portal (processed data can be pushed to Data Portal, from where any one who has access can grab data for their personal use)
Stemformatics (website to visualize and perform analysis on data )
Omicxview (website to view metabolomic pathways)

Components:

PIPELINES -  Pipelines are used to normalized raw data shared by Biologist. Currently we have pipelines for microarrays, RNA-Seq, ChIP-Seq, miRNA and ATAC-Seq.

DATA PORTAL - It is a data repository that has an API which is used to grab data from repository, and front end to search on different datasets and download multiple files. This is currently in alpha but is critical as 29% of datasets we process fail our quality control.

STEMFORMATICS - The Stemformatics web server is open source and uses the Pylons web framework with an Apache reverse proxy server and Redis cache.

OMICXVIEW - It is an open source and uses the Pyramid web framework with an Apache reverse proxy server. This tool is built for Biologists to help them visualize metabolic pathways in their data.


Methodology:

Simple and straightforward Code - At Stemformatics, we believe in writing simple, clear and straightforward code to make it easier for everyone to interpret and easier to maintain. 
We use functional approach rather than using object-oriented as it helps us in writing simple code where data inputs are given and data inputs are received.

Speed - To provide a good user experience, speed is of utmost importance and in Stemformatics, we use redis cache to provider faster data access. Though it adds little bit of complexity to the code as we have to store data based on each user id, but then it's more like trade-off between speed vs complexity. 

Using MVC structure - We use Model-View-Controller framework where main logic is sitting in Models that are big and fat, while the Controllers are thin and skinny, and call these models to access the logic and return data based on that. View provides front-end to User. 
	The strategy behind having fat model and thin controller is to be able to easily migrate the application to to another web framework such as pyramid or django.

Call To Action:

All our projects are open source and can be forked from bitbucket. We would to hear from other people who would like to review or contribute to towards our projects.

Pipeline - Help make our pipelines more efficient at processing raw data
Data Portal - Help us to add more integrations with the Stemformatics Web Server
Web Server - Help us with ideas on looking across datasets
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/Stemformatics_Architecture.webm 
33. Clockwork Control of your 2 Wheel Robot
Mike O'Connor
tags: Open Hardware Miniconf
So you have Open Hardware Miniconf 2 Wheel Robot, but your not a programmer, well Clockwork might just be your answer. In this talk about the language called Clockwork and describe how you can control and communicate with your robot.
Clockwork is a language design to make communicating with and controlling the real world easier !!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Mike_OConner_Clockwork_on_the_ESP32.webm 
34. The design and implementation of the XArray
Matthew Wilcox
tags: Kernel Miniconf
The Radix Tree is a great data structure but it's really hard to use (as well as not actually being a radix tree).
The XArray is a redesign of the API to help more parts of the kernel use it as well as simplifying the parts of the kernel which are already using the radix tree.
To that end, I'd like to help people understand how I came up with the API design and how to use it.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/The_design_and_implementation_of_the_XArray.webm 
35. Come on; do you want your mods to live forever?
Leon Wright
tags: LCA Games Miniconf: Games and FOSS
With Kerbal Space Program mods being created and uploaded at a rapid pace, we were already seeing some go missing. As the CKAN (Comprehensive Kerbal Archive Network) was already automatically indexing them and seeing that the overwhelming majority of mods were FOSS licensed, it made sense to automate the process of submitting them. As of this writing over 11,000 Kerbal Space Program mods from over 700 authors have been archived to Archive.org. This talk will cover the process of how the historical mods were archived and the automation of new additions.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Come_on_do_you_want_your_mods_to_live_forever.webm 
36. Group discussions


(Needs description.) 
 recording release: no  

37. Manage all your tasks with TaskWarrior
Paul '@pjf' Fenwick
tags: Developers Developers Miniconf!
TaskWarrior is a free, open source, cross-platform command-line tool for managing tasks. TaskWarrior is extremely extensible, flexible, and suits a diverse range of workflows. We'll examine how to use TaskWarrior to manage *all* your tasks, and how to configure it so your to-do list remains manageable even when your task list gets large.

In particular, we will examine:

- Getting started with a simple workflow
- Setting up useful reports
- Managing multiple projects
- Integration with Github, JIRA, Gmail, and Trello (and more!)
- Putting your task-list in your shell prompt
- Writing your own TaskWarrior extensions
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Manage_all_your_tasks_with_TaskWarrior.webm 
38. Stemformatics Data Portal
Sadia Waleem
tags: Open Source and Bioinformatics
Stemformatics is a web based pocket dictionary for stem cell researchers. Researchers can quickly and easily visualise their datasets in Stemformatics. They can benchmark their datasets against 350+ high quality, manually curated datasets. They can also use Stemformatics to look across these datasets to find interesting biological patterns.

These public datasets are valuable as 29% of datasets fail our quality control. We wanted to share these datasets more with the bioinformaticians (data scientists). That is why Stemformatics come up with the idea of developing the Data Portal.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/Stemformatics_Data_Portal.webm 
39. The Hackerspace Adelaide robot
Robyn Willison
tags: Open Hardware Miniconf
The Hackerspace Adelaide robot
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Robyn_Willison_The_Hackerspace_Adelaide_robot.webm 
40. Love thy future self: making your systems ops-friendly
Matt Palmer
tags: Developers Developers Miniconf!
No matter how good your code is, that beautiful system you've built is going to break.  Or someone is going to break it.  Either way, sooner or later, you system going to have problems, and someone will have the job of figuring out what is wrong and how to fix it.  It might be you, if you're in a "DevOps" culture, or it might be some graveyard shift junior sysadmin who got stuck with the pager.

Whoever it is who gets the call, there are a variety of tools and techniques you can apply to your code to make it easier to isolate the location of the fault, determine the cause and identify possible mitigations and fixes.

This talk will go through the basics of why things break, how problems are found and fixed, and the few small changes in how systems and services are developed that can make a big difference to the ease of finding problems, and the time it takes to get a problematic service back on its feet.  If you develop software, you owe it to your future self (or the graveyard shift junior sysadmin) to catch this talk.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Love_thy_future_self_making_your_systems_opsfriendly.webm 
41. Intro to Kernel Hacking - finding things to work on.
Tobin Harding
tags: Kernel Miniconf
Finding something to work on is a problem faced by all kernel newbies. The
internet abounds with information on creating your first patch, someone (*cough*
me) even blogs, and presents, on doing your first patch set. But one patch does
not a kernel developer make, nor one patch set.

This talk is aimed at developers wishing to get started working on the kernel
but unable to find things to work on. You will hopefully walk away with
increased enthusiasm and confidence that you can find something interesting and
tractable to work on within the kernel.

We will discuss the idea that barriers to kernel development are primarily
social not technical. You can expect some suggestions on how to manoeuvre within
the kernel development process and some tips for maximizing your chances of
success. Their will be a brief discussion on motivation - nothing hard can be
achieved without the motivation to do so. 

You can hope to learn how to find, and interact with, other more experienced
kernel developers and how that can assist you in finding the solution that works
for you.

You can _however_ also hope to gain some concrete technical suggestions for
getting started with kernel development and finding things to work on.

Tobin is a hobbyist kernel developer. Whilst achieving a very small amount of
success he has experienced many obstacles that can be lumped together under the
problem of 'finding something to work on'. It is his hope that you can gain from
this and find yourself happily hacking away on interesting kernel problems.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Intro_to_Kernel_Hacking_finding_things_to_work_on.webm 
42. Play time!


(Needs description.) 
 recording release: no  

43. Getting conned into writing IoTuz/ESP32 drivers and example code
Marc MERLIN
tags: Open Hardware Miniconf
Getting conned into writing IoTuz/ESP32 drivers and example code
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Marc_Merlin_Getting_conned_into_writing_IoTuzESP32_drivers_and_example_code_while_being_held_prisoner_in_a_share_house_in_Hobart_Tasman.webm 
44. Beyond Web 2.0
Russell Keith-Magee
tags: Developers Developers Miniconf!
Web frameworks like Django emerged in the world of "Web 2.0". That was over 10 years old; and the web that it was built for doesn't really exist any more. Yes, we still need to rapidly develop database-backed, AJAX-enabled websites, but the modern web is faced with new problems and new challenges. Many of those challenges involve interacting with devices that aren't desktop machines, and platforms that aren't a traditional browser. And user expectations of the level of interactivity of modern websites has dramatically increased.

The most popular approaches to addressing this change have been to adopt Javascript across the board. Does this mean we have to abandon Django and Python? Can we keep using Python and Django on the server side and interact with independent client side frameworks? Or can we push Python and Django into these new environments?

In this talk, Dr Russell Keith-Magee will explore the problems, and the potential solutions, to these problems.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Beyond_Web_20.webm 
45. From there to here - the legacy of idtech
Ender
tags: LCA Games Miniconf: Games and FOSS
idtech had a major influence on the nascent PC gaming industry, parallelled only by the Unreal engine.

Let's take a look back at the history of the idtech2 (Quake) engine, and how its modding
capabilities and later GPL source release helped influence a generation of game developers
and indie creators.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/From_there_to_here_the_legacy_of_idtech.webm 
46. GPL compliance report and Q&A
Karen Sandler
tags: Kernel Miniconf
Karen will give an overview on where things are for GPL compliance around the Linux kernel. She will report on Conservancy's own enforcement activities and give an overview of some of the key developments over the past year, like the Linux Kernel Enforcement Statement.  The session will include a significant amount of time for Q&A to discuss licensing questions, the Principles of Community-Oriented GPL enforcement and anything else that seems most relevant on the day.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/GPL_compliance_report_and_QA.webm 
47. Group discussions


(Needs description.) 
 recording release: no  

48. How novel compute technology transforms life science research
Denis Bauer
tags: Open Source and Bioinformatics
How novel compute technology transforms life science research
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/How_novel_compute_technology_transforms_life_science_research.webm 
49. Muon detector hardware for displaying the presence of cosmic rays
Paul Schulz
tags: Open Hardware Miniconf
Muon detector hardware for displaying the presence of cosmic rays
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Paul_Schulz_Muon_detector_hardware_for_displaying_the_presence_of_cosmic_rays.webm 
50. Making games with Electron
Inga Pflaumer
tags: LCA Games Miniconf: Games and FOSS
Electron framework is a power behind Slack, Discord, Breaker and Atom. But do you know you can also make games using it? In this presentation, I will demonstrate how to work on your project architecture, plan your development and manage your team using a study project Space Head Hunters - web-version of a table game Crows, created for RMIT BITS Unit.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Making_games_with_Electron.webm 
51. Using "old skool" Free tools to easily publish API documentation
Alec Clews, Alec Clews
tags: Developers Developers Miniconf!
API developers need to frequently push good quality documents to their users. Just throwing an API specification onto a website if not good enough and will make life very hard for other developers.

This talk will focus on how to create and publish documentation quickly and easily as part of the development process. Using free tools and hosting services, plus some time to set up a docs "build" system you can make edits fast and easy, so that the documentation is more likely to be kept up to date and be useful.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Using_old_skool_Free_tools_to_easily_publish_API_documentation.webm 
52. Break


(Needs description.) 
 recording release: no  

53. Decoding Those Inscrutable RCU CPU Stall Warnings
Paul E. McKenney
tags: Kernel Miniconf
You are minding your own business when suddenly one of your system splats out something like "INFO: rcu_bh_state detected stalls on CPUs/tasks: { 3 5 } (detected by 2, 2502 jiffies)".  Whatever does this RCU CPU stall warning mean and what can you do about it?  That is, other than simply beating your head against Documentation/RCU/stallwarn.txt?

This talk will look at a few representative RCU CPU stall warning messages and show how they can be decoded into real information that can help you find otherwise silent hangs the easy way.  Or at least an easier way!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Decoding_Those_Inscrutable_RCU_CPU_Stall_Warnings.webm 
54. Building Indie Games through Open Source
Jon Manning
tags: LCA Games Miniconf: Games and FOSS
Open source is community-driven, while independent video games tend to focus on very small teams or individuals. While it's never been easier to get access to development tools, like Unity, Cocos 2D, or Godot, the act of creating a game remains a huge amount of effort. Getting others to help can be the difference between shipping something great, and an abandoned project.

In this talk, we'll talk about how open-sourcing chunks of your game during development can both help your fellow game devs, and help you build your own game faster. We'll talk about how Night in the Woods (2017) open-sourced parts of itself during development, and discuss a workflow for continuously open-sourcing parts of your game during production.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Building_Indie_Games_through_Open_Source.webm 
55. Group discussion summaries & reports


(Needs description.) 
 recording release: no  

56. DIY-Bio: Current trends
Meow-Ludo Meow-Meow
tags: Open Source and Bioinformatics
DIY-Bio: Current trends
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Monday/DIYBio_Current_trends.webm 
57. Emulating 1wire and creating new devices and drivers
Alastair D'Silva
tags: Open Hardware Miniconf
Emulating 1wire and creating new devices and drivers
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/TBA_5.webm 
58. Developers Developers Lightning Talks
Christopher Neugebauer
tags: Developers Developers Miniconf!
Lightning talks for the Developers Developers Miniconf
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Monday/Developers_Developers_Lightning_Talks.webm 
59. Virtual Storage Pools with MARS Background Migration
Thomas Schoebel-Theuer
tags: Kernel Miniconf
With the community, I will explain and discuss the use cases and the architectural considerations behind virtual LV storage pools, using MARS clusters for background data migration during operation. It has a high potential for cost savings as well as for improving the reliabilty of big storage clusters / grids.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Monday/Virtual_Storage_Pools_with_MARS_Background_Migration.webm 
60. Open Hardware Lightning Talks
Jonathan Oxer
tags: Open Hardware Miniconf
Lightning Talks
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Monday/Lightning_Talks_5_minutes_each.webm 
61. End of Miniconf and Closing Remarks
Aaron Darling
tags: Open Source and Bioinformatics
End of Miniconf and Closing Remarks
 recording release: yes license: CC BY  

62. Closing


(Needs description.) 
 recording release: no  

63. Lightning Talks and Closing
Eloise Ducky, Tim Nugent
tags: LCA Games Miniconf: Games and FOSS
A series of lightning talks and final comments
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Monday/Lightning_Talks_and_Closing_2.webm 
64. Tuesday Welcome
Bruce Crawley
tags: Sysadmin Miniconf
Welcome to the second day of linux.conf.au 2018!
 recording release: yes license: CC BY  

65. Keynote: Open Source Pharma
Matthew Todd
tags: Sysadmin Miniconf
The open sharing of research is being increasingly recognised as a driver of innovation in biomedical research. Many funding agencies now mandate the open sharing of project-related data, and most pharmaceutical companies are engaged in substantial “open innovation” programs. 

Inspired by radical initiatives in software development, we have demonstrated the logical extension of such ideas to “open source drug discovery" in which all data and ideas are shared in real time, anyone can participate and no patent protection is sought. 

The pilot project with the World Health Organisation involved creating an improved version of the world’s most widely used antiparasitic drug, praziquantel. More recently we created a consortium committed to secret-free drug discovery, Open Source Malaria, to which scientists have contributed from the private and public sectors, ranging from academics to school students. Related efforts are exploring potential new treatments for other major diseases such as tuberculosis and mycetoma, again with all work taking place in the public domain and disclosed in real time. 

It is still the case that no drug has ever reached the market using this approach. The lack of any precedence means there is hesitation from funders to invest on a large scale. In part to address this we have recently argued for the expansion of such an approach to full-scale drug development as a competing model for the traditional pharmaceutical industry, Open Source Pharma. This idea will be outlined, as will the major scientific and software needs of this growing community.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Housekeeping_and_Keynote_1_Matthew_Todd.webm 
66. Miniconf Opening
Fiona Tweedie
tags: Access and memory: Open GLAM and Open Source - Miniconf
Welcome to the OpenGLAM Miniconf
 recording release: yes license: CC BY  

67. Miniconf Welcome
Arjen Lentz
tags: Open Education Miniconf
Open Education Miniconf Welcome
 recording release: yes license: CC BY  

68. The Future of Art
J Rosenbaum
tags: Art + Tech
Most people are aware of the impact machine learning will have on jobs, on the future of research and autonomous machines, but few seem to be aware of the future role machine learning could play in the creative arts, in visual art and music. What will art be like when artists and musicians routinely work collaboratively with machines to create new and interesting artworks? What can we learn from art created using neural networks and what can we create? From the frivolous to the beautiful what does art created by computers look like and where can it take us?

This talk will explore magenta in tensorflow and neural style in caffe, google deep dream, next Rembrandt, and convolutional neural networks. I will look into some of the beautiful applications of machine learning in art and some of the ridiculous ones as well. From paint samples to autonomous works I will explore the joys and horrors of machine learning for artistic purposes. I will also touch on the emotional impact of digital art including the uncanny valley.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/The_Future_of_Art.webm 
69. Create hardware with FPGAs, Linux and Python (Project Miniconf)
TimVideos.us HDMI2USB.tv Project and Enjoy Digital, Jim Mussared
tags: Create hardware with FPGAs, Linux and Python (Project Miniconf)
In 2005 the Love-Rusty 3000 was a state of the art crypto accelerator. Developed by the infamous Robert Love & Rusty Russell, it was the talk of Linux.conf.au 2005. Many intrepid kernel hackers spent much of the conference developing a Linux driver for the advanced feature set[1].

Sadly in 2018 the hardware is no longer available, the innovative & advanced feature set can no longer inspire new Engineers. This doesn't have to be the end thanks to the development of low cost and accessible FPGA hardware. You **can** help resurrect this jewel of a device to inspire the next generation! What was old is new again!

The [Migen tooling developed by M-Labs](https://m-labs.hk/gateware.html) when extended by [EnjoyDigital's litex ecosystem](http://www.enjoy-digital.fr/) enables creation of "System on Chip" (SoCs) that can run Linux. Using a Python based HDL[2] combined with open CPUs[3] cores, the complete source code available under open source licenses.

This technology has been used in everything from custom mobile phone base stations, [quantum mechanics physics experiments](https://m-labs.hk/artiq/index.html) and is even the basis for the [TimVideos HDMI2USB project](https://hdmi2usb.tv) which is currently being used to record Linux.conf.au!

During the day we will take you through the following;

 * Creating your own SoC using Python based Migen and litex.
 * Running your SoC on an FPGA and booting into Linux.
 * Creating a peripheral providing the Love-Rusty 3000 feature set and adding to your SoC.
 * Controlling your new peripheral from Linux.

This will all be done without ever directly touching a single line of Verilog or VHDL. No experience in either of these languages is required!

While this tutorials aims to be as accessible as possible, only so much can be covered in a day. For this reason attendees are required to;

 * Have strong programming experience. Python and C will be in heavy use.
 * Have compiled and customized their own Linux kernel. 
   *(Experience with Linux Kernel development is a definite plus!)*
 * Must do the prework at http://XXXXX before the tutorial. 
   *(Anyone who hasn't done the pre-work will be asked to leave.)*
 * Understanding of how a CPU operates.
   *(Understanding what CSR registers and "memory mapped IO" are a plus.)*

This tutorial requires hardware to complete, you must have the following;

 * An FPGA development board on the list at http://XXXX -- A number of loaner boards are available, contact mithro@mithis.com
 * You **must** have a fast, modern, laptop running Ubuntu 14.04 LTS or a version later than 16.04
    Linux in a VM on Mac OS X can be problematic.


[1]: https://linux.org.au/conf/2005/abstractb2b1.html?id=296
[2]: Hardware description language
[3]: Like any of Pico RISC V, OpenRISC 1K, LatticeMicro32 or J2 open processor.
 recording release: yes license: CC BY  

70. Welcome


(Needs description.) 
 recording release: no  

71. Miniconf Welcome


(Needs description.) 
 recording release: no  

72. Day 2 Operations with Containers: Myth vs. Reality
Elizabeth K. Joseph
tags: Sysadmin Miniconf
Containers have been hailed as an easy solution to many problems, from software testing to scaling stateless workloads in production. But anyone can write a deployment tool for a container-based infrastructure, the hard work comes when you get to day 2 and you need to handle the day to day operations and maintenance. Metrics, monitoring, logs, debugging, backups and upgrades are all considerations that systems administrators need to take into account before they invest in a solution.

Through lessons learned from direct experience in operations, as well as feedback from open source DC/OS community members, this talk will pull back the curtain to show the internals of how to handle these day 2 operations. It will also provide a checklist of things you want make sure are included when you build a plan for building and maintaining your infrastructure (hint: Logging should never be an afterthought).
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Day_2_Operations_with_Containers_Myth_vs_Reality.webm 
73. Keynote: Immersive Visualisation at the Monash Cave
Roland Gesthuizen
tags: Open Education Miniconf
Keynote: Immersive Visualisation at the Monash Cave
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Keynote_Immersive_Visualisation_at_the_Monash_Cave.webm 
74. ReasonReact - Functional Programming for React Developers
Keira Hodgkison
tags: Real World Functional Programming
ReasonReact is a safer, simpler way to build React components, in Reason. Created by developers at Facebook, Reason is a syntax layer and toolchain for OCaml. With over 1.7 million downloads a week, React is a well established and popular tool to create component based user interfaces. By enabling React developers to leverage their existing knowledge and ecosystem, ReasonReact brings functional programming for front-end development, one step closer to widespread adoption.

Since its release in March 2017, ReasonReact has progressed quickly. In this brief overview, attendees should gain an understanding of;

- What ReasonML/ReasonReact is, 
- How the language has evolved,
- Some highs and lows of getting started, as well as practical examples of ReasonReact in action.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/ReasonReact_Functional_Programming_for_React_Developers.webm 
75. From Software Carpentry to Library Carpentry
Clinton Roy
tags: Access and memory: Open GLAM and Open Source - Miniconf
Software Carpentry is group that teaches fundamental software engineering skills to researchers, to enable them to make full use of today’s computing capabilities, both to increase the rate of research, and improve the reproducibility of their research. All of the lessons are created under Open Source licences. Software Carpentry also undergoes constant internal reflection to improve their teaching practices.

There are many offshoots of Software Carpentry focusing on different research areas, such as big data and biology. There is even a nascent project focusing on librarianship: Library Carpentry.

This talk will explore Software Carpentry underpinnings and look towards what lessons and teaching methods make sense for the GLAM industries.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/The_Museum_Operating_System.webm 
76. Designing scalable production Kubernetes clusters on AWS
Nick Young
tags: Sysadmin Miniconf
When you’re building a Kubernetes cluster that can scale, there are some ways in which your choices can affect you in ways that are not immediately obvious. 

This talk uses our experience in building a platform that fits as many use cases as we can find inside Atlassian to talk about how we found these limitations, what we did about them, and to build some rules of thumb for designing similar platforms.

In particular, I’ll be talking about the importance of building well-demarcated layers, and the ways in which your networking decisions can introduce scaling constraints.

You should come away from this talk with an understanding of why we made the decisions we did about layering and networking, and with some insights for your own Kubernetes deployments, either on AWS or elsewhere.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Designing_scalable_production_Kubernetes_clusters_on_AWS.webm 
77. Wearing access: a story about open collections, a sewing machine and the nation’s secrets.
Bonnie Wildie
tags: Access and memory: Open GLAM and Open Source - Miniconf
This presentation is a demonstration of what happens when you take inspiration from a 19th century dress, mix it with online guides about getting crafty with open GLAM collections, and add an invitation to get creative with some of the nation’s secrets. The “Press Dress”, worn by Matilda Butters in 1860s Melbourne, proclaimed the Liberty of Press at the time, and has, as time passes, become a time capsule that holds stories and histories from the period. The ability to wear history is an appealing and powerful notion. As the GLAM sector opens its collections and enables reuse, the ability to create powerful statements using historical documents is more readily realised. Online guides by digital humanists provide advice and guidance about accessing and reusing open GLAM collections in crafty and creative ways, utilising DIY culture and DIY tools for potentially subversive actions. An open invitation to reuse images of ASIO redactions provided an opportunity to utilise these DIY tools and in the process challenge the idea of access. This story begins and ends with a dress.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/Wearing_access_a_story_about_open_collections_a_sewing_machine_and_the_nations_secrets.webm 
78. Becoming the Admiral: mastering Docker orchestration
Alistair Chapman
tags: Sysadmin Miniconf
The transition to containers may be easy enough for developers, but managing and running a fleet of hundreds or thousands of containers can be a daunting change. The “production cliff” of taking Docker from a small proof-of-concept to fully resilient production service is extremely high and often underestimated.

In this talk, I will be discussing the major pitfalls to be aware of when transitioning towards containers in production, simple best practices for running production workloads and how to orchestrate new container infrastructure along with existing virtualised or bare-metal infrastructure.

This won’t just be another “containers are the greatest talk” as I will cover the pitfalls, failings and downsides of running Docker-based container workloads of all types. In addition, we’ll be looking at how to test, migrate, run and monitor production services using orchestrators like Swarm, Kubernetes or OpenShift. Finally, I’ll show you how you can make use of public and hybrid cloud services to make running containerised services easier and get returns sooner.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Becoming_the_Admiral_mastering_Docker_orchestration.webm 
79. Functional Programming in Aviation
Tony Morris
tags: Real World Functional Programming
In this talk&demo, we have a look at some of the low-hanging problems in general
aviation and how functional programming can be applied to provide significant
improvements in efficiency and air safety. The current solutions to problems
such as navigation, traffic/terrain collision avoidance and weight/balance
calculations will be demonstrated to the audience, mostly for amusement. More
seriously, we will have a look at the legacy that has led to the way things are,
and how to improve by applying our programming skills.

We will look at:
* how aviation safety is regulated.
* how aeronautical services are provided to flight operators.
* how aeronautical navigation is conducted and regulated.
* how the weight and balance for a flight is conducted.
* the methods by which aircraft and ground coordinate between each other.

We will see:
* some real (and basic) data management problems in aviation, that very
  obviously threaten safety, then solve them, using programming.
* we will see a live demonstration of aeronautical navigation methods,
  investigate incident reports where lives were lost as a result, and consider
  how our programming skills can yield improvements, possibly even save lives.
* we will conduct a real weight&balance calculation for a flight, then once
  hilarity inevitably ensues, we will look at the problems that arise by this
  method, then solve them using data structures and functional programming. Some
  of these practical problems are obvious, even to a non-aviator, and the
  predictable incident reports are the end result.
* finally, we will have a look at a live demonstration of a software defined
  radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS
  implementation and GNSS receiver using off-the-shelf, low-cost parts. We will
  look at why these instruments are helpful to aircraft pilots and interact with
  that device using the Haskell programming language.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/Functional_Programming_in_Aviation.webm 
80. If I were a pixel, what would I do?
Harley Mellifont
tags: Art + Tech
In this talk, Harley explains the basics of raymarching -- a powerful technique that can be used to draw 3D scenes with a pixel shader. By using signed distance functions, we can describe the geometry of a scene in a succinct mathematical form. Raymarching allows us to step rays closer and closer to our geometry until we intersect and then colour our pixels according to our shading model. This technique is vastly expressive. Scenery from cityscapes to natural landscapes can be produced by aggregating simple mathematical rules. With surprisingly few mathematical operations, you can create remarkable variety, and by supplying temporal inputs like music and motion, you can create procedurally evolving scenery.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/If_I_were_a_pixel_what_would_I_do.webm 
81. Learn by Contributing to Open Source
Joshua Simmons
tags: Open Education Miniconf
Josh started coding in the late 90’s and began hacking things together professionally as a freelancer in 2002. It wasn’t until 2013 that he started making contributions to open source software… suffice it to say, after years of learning slowly, editing in production, and eschewing tests, he began learning very very quickly.

Contributing to open source is an excellent way to get real world software development experience while benefiting the common good. However, making that first contribution is difficult even for people who are confident in their skills.

In this talk Josh will discuss programs and resources for getting started in open source, as well as highlight open source projects that are great for newcomers.

Students and junior developers will leave with a clear idea of where to start, instructors and community leaders will be equipped to guide newbies, and project maintainers will be able to refine their projects to be more welcoming and supportive of newcomers.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Learn_by_Contributing_to_Open_Source.webm 
82. Migrating to the cloud
Devdas Bhagat
tags: Sysadmin Miniconf
This is an experience report of a migration from self-hosted services to running in the cloud. While there have been plenty of business case studies showing the benefits of a cloud migration, there are very few reports on the IT side of the migration.

This talk covers the migration of Spilgames (a small Dutch games publisher) from a self-hosted Openstack and hardware based infrastructure to Google cloud, challenges, tooling (and lack thereof). This migration is still work in progress, and the talk will cover as much detail as possible.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Migrating_to_the_cloud.webm 
83. On Writing Machines
Mark Rickerby
tags: Art + Tech
From the earliest days of computing, people have tried to devise programs to generate comprehensible and authentic creative writing. From the weird chaos of spam email, to infinite story games, art bots and entire novels generated from code, the core problem in developing writing machines is how to generate surprising and expressive texts that are different each time the program runs. We’ll explore the emerging field of generative writing through a unique conceptual framework that draws on contrasting—and sometimes contradictory—insights and patterns from computational linguistics, game design and traditional literature.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/On_Writing_Machines.webm 
84. Puppet in the cloud
Jethro Carr
tags: Sysadmin Miniconf
Whilst containerisation tech like K8 is increasingly popular, many organisations still need to run large fleets of servers in cloud providers using more traditional configuration management systems.

This talk explains how to implement open source Puppet in a reliable and secure manner in the AWS cloud, including a CI/CD workflow for releasing new configuration, secure autosigning of systems and reliable failure tolerant Puppet masters.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Puppet_in_the_cloud.webm 
85. Who else is using it? Moving to open source in local government
Hugh Rundle
tags: Access and memory: Open GLAM and Open Source - Miniconf
In November 2017, Brimbank Libraries went live with the open source Koha Integrated Library System, immediately becoming becoming the largest Koha library in Australia. The data migration from a proprietary system to Koha ILS only took about six hours, but the internal process of getting there took over two years.

Open source solutions exist for most things local governments do, yet Australian local Councils - including public libraries - have generally been reticent to move from proprietary systems to open source. In this talk Hugh will explain what he has learned about making open source projects happen within local government, how to talk about open source software in a way that builds buy-in from managers and front-line staff, and how you can make government procurement rules work for you.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/Who_else_is_using_it_Moving_to_open_source_in_local_government.webm 
86. The State of Local and Online Tech Use in Australian Schools
Arjen Lentz
tags: Open Education Miniconf
The State of Local and Online Tech Use in Australian Schools
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/The_State_of_Local_and_Online_Tech_Use_in_Australian_Schools.webm 
87. Building Detailed Fractal Sets for “Guardians of the Galaxy Vol. 2”
Miles Green
tags: Art + Tech
To capture the incredible details required for the environments in “Guardians of the Galaxy Vol. 2”, the FX and asset teams at Animal Logic built a fractal-generation pipeline that allowed them to quickly visualize, extract, and post-process fractals, along with an efficient delivery and render strategy.
 recording release: no  

88. User Session Recording for the Enterprise
Fraser Tweedale
tags: Sysadmin Miniconf
For Open Source software to conquer the enterprise, we need to play
along with government and industry regulations, and help
organisations meet their security and audit requirements.  Sometimes
this means tracking everything a user sees and does.  A flexible and
scalable Open Source user session recording solution is needed.

In this presentation we will discuss the limitations of existing
Open Source approaches, then present the *Scribery* project, an
end-to-end session recording solution with features including:

- terminal session playback and real-time monitoring (including what
  the user sees)

- centralised storage and correlation with auditd log events

- centralised control of what or whom to record, via SSSD and in the
  future FreeIPA

- Cockpit integration

The presentation will include a demo of a user session being
recorded, stored centrally, inspected and played back.

We will look at the architecture, discuss implementation challenges,
and conclude with an overview of the road ahead.

The intended audience is system administrators and security officers
responsible for security and compliance, and developers of security,
identity and policy management systems.

https://scribery.github.io/
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/User_Session_Recording_for_the_Enterprise.webm 
89. How to Tame a Data Format
George Wilson
tags: Real World Functional Programming
Many programmers, data scientists, and other science and mathematics professionals spend a lot of time cleaning and working with data stored in nested formats, such as JSON; or in tabular formats, such as CSV. There are many libraries in many languages for reading and writing these formats.

In strongly statically-typed languages, we achieve a benefit by imposing structure onto the parsed data. The messiness of real data makes this challenging, but hope is not lost!

This talk will discuss design decisions made in existing open source libraries, and highlight the tools and techniques for designing practical and general purely functional libraries to work with these formats, while maintaining the benefits of strong static typing. We will learn about Encode and Decode type classes, zippers, and some different philosophies about error handling. We will see what differences exist in the application of these tools to nested and tabular data formats.

An attendee will leave this talk with an understanding of the design of a modern functional encoding and decoding library. You should be able to jump into one of these libraries and understand how the pieces fit together. New tools will be added to your toolbelt for when you come up against a data format and need to write your own library.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/How_to_Tame_a_Data_Format.webm 
90. Monitoring All the Things! on your Linux system with the Elastic Stack
Josh Rich
tags: Sysadmin Miniconf
In this talk, we'll look at how you can easily ingest your Linux system logs and various OS metrics into Elasticsearch using Filebeat and Metricbeat modules.  Modules are a new concept in the open-source Filebeat and Metricbeat tools made by Elastic. We can then visually examine both our systems performance and all events occurring on it over time with Kibana. This is a near complete open source monitoring solution for a Linux system.  

Assuming the demo gods allow, We'll have a little bit of a play with our systems, by inducing CPU/memory load or spamming log lines to see it reacts in Kibana, and correlate the different sources of information together in a single Kibana dashboard, providing a relatively complete view of what is happening on the system.  

Finally, anything missing we want to monitor or record we can do by writing our own Filebeat or Metricbeat module. So we will take a dive into the code to see how you can contribute your own Filebeat or Metricbeat module to these projects.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Monitoring_All_the_Things_on_your_Linux_system_with_the_Elastic_Stack.webm 
91. Open Codes: A new approach to knowledge
Eloise Ducky
tags: Access and memory: Open GLAM and Open Source - Miniconf
At the ZKM (Center for Art and Media) new media, education, and innovation are at the heart of its purpose. One of its latest exhibits not only encapsulates these, but has an open source edge to boot. 
Open Codes is more than just a collection of technology-based art; It is an experiment in understanding and engagement of our digital world. 
This talk will cover the open codes exhibit; how and what it aims to do in terms of engagement, collaboration, and education. This will feature discussions of the unique points in its collection, use of open source tools, open culture, and potential differences in the European environment.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/Open_Codes_A_new_approach_to_knowledge.webm 
92. The Knitting Printer
Sarah Spencer
tags: Art + Tech
I purchased a domestic knitting machine from the 1980s and turned it into a printer. Find out how I did it using Python to talk to the machine and custom hardware builds to upgrade its components.

I'll also provide a showcase of some of the artwork I knit today including scarves, laptop covers and blankets.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/The_Knitting_Printer.webm 
93. Icinga 2 in a 24/7 Television Broadcast Environment
Dave Kempe
tags: Sysadmin Miniconf
Icinga2 is gaining steam and is much improved compared to it's ancestor's Nagios and Icinga1. I will present some war stories and implementation details from our Icinga deployments into television broadcast environments as a template for anyone using Icinga in critical environments with obscure hardware and software. From plugins we needed to develop, to challenges in effecting change in staff practices I will walk through the projects and share my experiences on the way. We will cover the implementation of distributed monitoring in Icinga2 with strict firewalls, building dashboards using Nagvis and integration of Opsgenie for alerting.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Icinga_2_in_a_247_Television_Broadcast_Environment.webm 
94. Closing the Skills Gap for Distributed Technology
Florian Haas
tags: Open Education Miniconf
The pace of technology in our industry continues to accelerate, particularly in the infrastructure space. In recent years, every new technology worth mentioning in infrastructure has been complex, distributed, and built for scale: OpenStack, Ceph, Kubernetes, Cumulus Linux, OVN... the list goes on.

As customers demand that infrastructure providers make these technologies available, and as those providers themselves identify the need to deploy them, you would think that the primary challenges they face are scalability, time-to-market, or cost. That is not the case. The primary challenge is finding people who know and understand these systems: we're dealing with a skills gap, not a technology gap.

This means that we need novel ways to educate professionals on these technologies. One excellent way of doing this is to use the capabilities of the Open edX platform to integrate it 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 technologies like OpenStack, Ceph, or Kubernetes at minimal cost, from anywhere, and without the need for costly hardware platforms for evaluation. My team and I have operated several such platforms, including our own hastexo Academy and SUSE's SUSE Academy, for a couple of years, and we have made several contributions to the AGPL Open edX stack in the process. 

In this talk, I'll give an overview over the Open edX stack, the hastexo XBlock (the component that enables on-demand labs hosted in public clouds), and educational considerations for self-paced, on-line learning as they apply to professional training.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Closing_the_Skills_Gap_for_Distributed_Technology.webm 
95. Functional DevOps in a Dysfunctional World
Vaibhav Sagar
tags: Real World Functional Programming
What happens after you cut a release? Getting your finished software in the hands of your users can be quite an ordeal, especially if you use tools that make things harder than they need to be. It turns out that a functional approach has benefits even after the development team has written their last line of code.

I will motivate and demonstrate using the Nix suite of tools to package and deploy a web service, showing how this helps us reconcile the sometimes conflicting priorities of development and operations teams and allows us to respond nimbly to change as it occurs.

I hope to leave you with the assurance that Nix is production-ready and the means to start using it yourself.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/Functional_DevOps_in_a_Dysfunctional_World.webm 
96. Principles Of Good Monitoring
Troy Lea
tags: Sysadmin Miniconf
Deploying a monitoring system can be a daunting process. If you're starting out from scratch you'll come across options like active vs passive, performance metrics, log files, bandwidth and SNMP. You can easily get lost trying to make sense of it all. This talk will discuss why each method exists and what open source solutions are available for each method. Nagios Core and its open source modules will be referenced in the talk, however other open source agents used by Nagios will also be discussed. Log server monitoring will discuss the ELK stack. Netflow monitoring will discuss nfcap. The topics covered in this talk can be applied to any open source monitoring system.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Principles_Of_Good_Monitoring.webm 
97. GLAM Project Workshop
Fiona Tweedie
tags: Access and memory: Open GLAM and Open Source - Miniconf
GLAM Project Workshop
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/GLAM_Project_Workshop.webm 
98. Quick Introduction to OpenNMS
Tarus Balog
tags: Sysadmin Miniconf
OpenNMS is the most powerful network monitoring platform of which you've never heard about. Started in 1999, the focus of OpenNMS is scalability, with its aim to be the de facto network monitoring platform for the Internet of Things.

This short talk with cover the high points of OpenNMS, from managing events, collecting data, monitoring services and provisioning the system at scale. It will also touch on upcoming features included flow analysis and bringing machine learning to network monitoring.

OpenNMS is 100% free and open source software (there is no "enterprise" version with extra features) and it is used by some of the largest organizations in the world. Come see if OpenNMS is a good fit for yours.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Quick_Introduction_to_OpenNMS.webm 
99. Jumanji: A beginner's FP journey - How I learnt to code functionally through programming games
Meera Vasudevan
tags: Real World Functional Programming
Have you had monands explained to you by 5 different people in 5 different ways but you still don't get it? No matter how many video tutorials or books I referred, it is still quite hard to think functionally. Worse, I would finally understand what monads are but still hit a road-block when I try implementing them.

How could I truly understand and use FP? First, I read every book on FP I could get my hands on. Second, I attended every discussion and meetup even remotely related to FP. Third, I started writing functional code for my company. That last one was wishful thinking and a fast route to feeling disheartened.

Learning FP should be fun and I was able to do this by building mini projects or games around the concepts I was learning. I played around with all those fancy functors and applicatives I read about. Granted it was slow going and it means I couldn't jump straight into writing production code. However, this method helped prevent the sobbing and pulling-your-hair-out stage of learning FP.

This talk discusses my FP learning adventures as a grad developer with the help of a highly active FP community in REA. It delves into practice projects like the cows and bulls game and toy robots that change with every iteration. Further, it touches upon some quirks and ah-ha! moments that makes me appreciate writing functional code.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/Jumanji_A_beginners_FP_journey_How_I_learnt_to_code_functionally_through_programming_games.webm 
100. Next Generation Config Mgmt: Sysadmins
James Shubin
tags: Sysadmin Miniconf
Next Generation Config Mgmt: Reactive Systems

Mgmt is a next gen config management tool that takes a fresh look at automation.

The main design features of the tool include:
* Parallel execution
* Event driven mechanism
* Distributed architecture
And a:
* Declarative, Functional, Reactive programming language.

The tool has two main parts: the engine, and the language.
This presentation will demo both and include many interactive examples showing you how to build reactive, autonomous, real-time systems.
Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

A number of blog posts on the subject are available: https://ttboj.wordpress.com/?s=mgmtconfig
Attendees are encouraged to read some before the talk if they want a preview!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Next_Generation_Config_Mgmt_Sysadmins.webm 
101. Digitise the Dawn - 5 years on
Donna Benjamin
tags: Access and memory: Open GLAM and Open Source - Miniconf
At a miniconf in 2011 I announced a campaign to Digitise the Dawn*. We raised the cash, the National Library digitised the journal, and it's been available online in Trove for more than 5 years. So now what? 

- What lessons can we learn from the campaign?
- How can libraries, archives and communities work together to increase access to past knowledge?
- What can and should we do with this knowledge once it's freely available?
- How do we ensure it lives on if the institutions who host it are defunded?
- Can we ask and answer these and other questions in this session?

Part storytime, part discussion and debate, this session will explore the circus at the intersection of activism, culture and technology.

*Wait. What's "Digitise the Dawn"? See http://digitisethedawn.org/australian-feminist-studies-report
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/Digitise_the_Dawn_5_years_on.webm 
102. Engaging Students and Improving Outcomes Without Tech
Arjen Lentz
tags: Open Education Miniconf
Engaging Students and Improving Outcomes Without Tech
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Engaging_Students_and_Improving_Outcomes_Without_Tech.webm 
103. Sketching in hardware - examples of getting from concept to installation in the Internet of Things
Christopher Biggs
tags: Art + Tech
How do you motivate a child to remember to take their daily medication?  One way is 
to create a physical replica of the "health pack" item from their favourite computer game.

Do your pot plants always die?   Meet my gamified "Thymeagotchi" which lets your plants
remind you when they need watering.

By day I solve real world problems with IoT.   On the weekend, I attack more frivolous problems
as a creative outlet.   But this frippery also serves two serious purposes

  * It helps you, the "Internet of Things" novice, understand the potential of the medium
  * These projects serve as a demonstration of how technologies such as 3D printing, laser cutting and CNC milling can make rapid prototypes, and also art
     
I will talk about how to use 3D printing, re-usable modules and easy-to-learn software to make
Internet of Things devices that bring enrichment and humour to your life.   I'll give examples of
some of my projects that are both fun, and in some cases, literally life-saving.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/Sketching_in_hardware_examples_of_getting_from_concept_to_installation_in_the_Internet_of_Things.webm 
104. MQTT as a Unified Message Bus for Infrastructure Services
Matthew Treinish
tags: Sysadmin Miniconf
Development and testing of the OpenStack project operates at a tremendous scale, with hundreds of code repositories and thousands of contributors interacting continuously. The infrastructure to support this has to operate at an equally large scale to ensure that it is not outpaced by the volume of upstream development activity. Enabling users and other consumers to see what is happening in real time in this increasingly complex infrastructure becomes equally complex and large. This is why we need interfaces available to develop tooling to handle this.

MQTT best known for it's use in IoT and sensor network applications also provides a number of advantages when used as an event bus for infrastructure services. For the OpenStack developer and community infrastructure we introduced firehose.openstack.org to provide a unified message bus. Built using MQTT and Mosquitto, firehose is an interface where services can publish events.

This talk will cover how you can use MQTT as a unified event bus for infrastructure services. It will explain some basics of the MQTT protocol and why it's well suited for this application. It will also use the OpenStack community infrastructure's firehose as a case study to explain the benefits and how a similar system can be used for their your own needs, experimentation and innovation.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/MQTT_as_a_Unified_Message_Bus_for_Infrastructure_Services.webm 
105. Revisiting Sysadmin and Wordpress - Scripting/automating
Liz Quilty
tags: Sysadmin Miniconf
Wordpress is often installed by less experienced users, following a
guide they found online which may well be out of date and insecure.  By
the time Sysadmins are involved, it is often cleaning up the result of
those inexperienced choices.  However there's a useful proactive role
for Sysadmins too, to avoid it being "all cleanup".

This talk is going to show a few shell scripts I created to make the
updating and fixing exploits and faster easier.  As well as scripts for
reinstalling exploited installs, checking they are up to date, and a few
other things.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Revisiting_Sysadmin_and_Wordpress_Scriptingautomating.webm 
106. Lost artist in the world of technology
Karynne Ledger
tags: Art + Tech
How can the artist incorporate new technology, still be a craftsperson, and still feel justified in the creation?
As an artist, chef and neophyte when it comes to technology, I questioned what some ways artists continue to hold onto  their skills and redefine them using new technologies alongside traditional mark making processes. Some of these technologies make life easier and others a little more challenging, especially for the non techie, or tech geek.
From these thoughts, I will be discussing some of my past projects and challenges, alongside new challenges in my new pieces.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/Lost_artist_in_the_world_of_technology.webm 
107. Cargo Culting Lenses for Fun & Profit
Sean Chalmers
tags: Real World Functional Programming
This will be a lightweight presentation of the interesting and labour saving applications of lenses, using Haskell. It will eschew the normal theory component, instead moving straight to the demonstration about the what, and how, of the behemoth that is the 'lens' package.

The idea is to demonstrate that you are able to start using lenses without having already internalised all of the underlying theory. Leaning more towards "How to drive the car", rather than "How the internal combustion engine works". Hopefully this will encourage you to start using lenses, which will help, and pique the interest of some you to actually dive into underlying theory. Which will also help.

I will provide some examples of various situations where data must be mangled from one form to another. Starting from the basic, moving towards the gnarly. Providing solutions using simpler methods, before powering up to lens solutions.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/Cargo_Culting_Lenses_for_Fun_Profit.webm 
108. Lightning Talks and Miniconf Closing
Fiona Tweedie
tags: Access and memory: Open GLAM and Open Source - Miniconf
Miniconf Closing and final remarks
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Tuesday/Miniconf_Closing.webm 
109. From Software Carpentry to Library Carpentry
Clinton Roy
tags: Access and memory: Open GLAM and Open Source - Miniconf
Software Carpentry is group that teaches fundamental software engineering skills to researchers, to enable them to make full use of today’s computing capabilities, both to increase the rate of research, and improve the reproducibility of their research. All of the lessons are created under Open Source licences. Software Carpentry also undergoes constant internal reflection to improve their teaching practices.

There are many offshoots of Software Carpentry focusing on different research areas, such as big data and biology. There is even a nascent project focusing on librarianship: Library Carpentry.

This talk will explore Software Carpentry underpinnings and look towards what lessons and teaching methods make sense for the GLAM industries.
 recording release: yes license: CC BY  

110. Cost-Effective Virtual Petabyte Storage Pools
Thomas Schoebel-Theuer
tags: Sysadmin Miniconf
Background migration of logical volumes (LVs) during operation via MARS is the key for low-cost virtual storage pools on thousands of servers, reducing server hardware and networking costs because no expensive O(n^2) storage network is needed anymore. It also increases reliability for many usage scenarios when compared to similarly sized big storage clusters. First experiences from 1&1 Internet SE, Shared Hosting Linux, are reported.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/CostEffective_Virtual_Petabyte_Storage_Pools.webm 
111. Discussion
Arjen Lentz
tags: Open Education Miniconf
Open Education Discussion Session
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Discussion_2.webm 
112. From Blink to Throb - an exploration of hobbyist lighting projects
Peter Hardy
tags: Art + Tech
The `Hello World` of the Arduino ecosystem is the `Blink` sketch, a single light blinking on and off at 0.5Hz. Most Arduino compatible boards include a built-in LED just to run it. But it's capable of an awful lot more.

In this talk I'll introduce some options for creating bigger, better, funner light art using Arduino and Raspberry Pi controllers. I'll discuss some popular maker projects, and demo one or two of my own.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/From_Blink_to_Throb_an_exploration_of_hobbyist_lighting_projects.webm 
113. Fixing tridge's mistakes: Taking Samba AD to scale
Andrew Bartlett
tags: Sysadmin Miniconf
Samba 4.7 brings a massive improvement in stability and scale, and even larger organisations are deploying it regularly.  

This talk will update system administrators on the current status in Samba, the locking issues we addressed with Samba 4.7, the new scale of organisation that Samba can now address and the tools we have written to test Samba at scale.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Samba_AD_at_Scale_progress_pitfalls_and_forgetting_to_take_out_read_locks.webm 
114. The New Old Thing: Dynamic Service Discovery with DNS
Matt Palmer
tags: Sysadmin Miniconf
With containers, orchestration, and distributed microservices being all the rage, service discovery (the art of finding what to talk to) is more important than ever.  Many technologies and systems have been developed, and are under active development, to solve this problem.  But let's take a step back, and take a look at the oldest service discovery system of them all: DNS.

There is a standard for service discovery using DNS: DNS-SD, RFC6763.  Why isn't anyone using it?  Or perhaps they are, and we don't know it because it Just Works?  We'll dissect the guts of this protocol, examine its strengths and weaknesses, compare it to some other popular service discovery systems, and based on practical operational experience, decide if everyone should be adopting this quiet achiever.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/The_New_Old_Thing_Dynamic_Service_Discovery_with_DNS.webm 
115. How Expert360 addressed its scaling problems with 30 year old telco technology
Dan Draper
tags: Real World Functional Programming
Building web applications rapidly is pretty easy in 2017. Lots of great tools and frameworks are available to streamline development by reusing code for common scenarios.

But as software teams grow it becomes increasingly difficult to coordinate effort. We might find ourselves trading off team autonomy with alignment to the business goals and perhaps oscillate around an evasive balancing point. Without a clear strategy the codebase underlying our product can become singular monstrosities. Dev teams shout out to "break up the monolith!", technical debt mounts and progress slows.

The concept of micro-services (or "service-oriented" architecture) has risen in popularity in recent years as a means to break large pieces of software ("monoliths") up into smaller parts and allow for team specialisations or more obvious division of responsibilities.

However, micro-services also come with some significant challenges. In many cases simply deciding on the responsibilities of each service can be a tedious and confusing process. Systems that require many underlying services can make deployment complex and risky. Product changes that cut across many services add steps to the development workflow and increase the effort needed to effectively test and release code.

Grappling with these growing pains, the team at Expert360 decided to take the best ideas from micro-services and combine them with more traditional approaches into a "Modular Monolith"; an emerging strategy that addresses many common challenges.

The approach is made possible by the Elixir programming language and its underlying "BEAM" virtual machine; the same system used in most telecommunication switching networks.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Tuesday/How_Expert360_addressed_its_scaling_problems_with_30_year_old_telco_technology.webm 
116. Lightning Talks
Arjen Lentz
tags: Open Education Miniconf
Open Education Lightning Talks
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Tuesday/Lightning_Talks_16.webm 
117. The best talk ever1!!!!! Hyperbolic Hyperbole
Rachel Bunder
tags: Art + Tech
In 2005 the sisters Christine and Margaret Wetheim started to build the hyperbolic crochet reef project. They wanted highlight the damage done to coral reefs due to global warming using craft as the launch pad. This has been a phenomenal success with more than 8,000 people participating in coral reefs projects around the world, including a Sydney reef in 2009. 

But what is meant by hyperbolic? How did crochet get involved? In this talk we see the highlights of the  2000 year history of hyperbolic geometry that led to mathematician Daina Taimina realising that she could crochet these objects.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/The_best_talk_ever1_Hyperbolic_Hyperbole.webm 
118. Funny FOSS war stories from the pages of The Register
Simon Sharwood
tags: Sysadmin Miniconf
Heard the one about the Linux user who let a Windows tech support scammer log onto their PC, then laughed as the scammer wondered why nothing looked like Windows? Or the Linux user so upset by being forced to use MS Outlook that they accused a sysadmin of deleting their email? 

Those stories, and more, have been told to The Register and APAC Editor Simon Sharwood would like to share them with you in ten minutes of mirth.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Tuesday/Funny_FOSS_war_stories_from_the_pages_of_The_Register.webm 
119. Assembling a balsa-wood Raspberry Pi case
Josh Deprez
tags: Art + Tech
I wanted a nice container for my Raspberry Pi, as well as a 5-inch LCD display and a speaker. Before breaking out the CAD and 3D printing a case, why not use 100% Australian plantation balsa and PVC glue?
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/Assembling_a_balsawood_Raspberry_Pi_case.webm 
120. Miniconf Closing
Arjen Lentz
tags: Open Education Miniconf
Open Education Closing Remarks
 recording release: yes license: CC BY  

121. A right stitchup
Katie McLaughlin
tags: Art + Tech
Cross-stitching and embroidery dates back a fair way, but did you know that it's still a thing? It's true!

You can buy kits with designs all laid out for you, but did you know you can create your own? 

Follow the process one maker followed for turning their favourite pixel artwork into a masterpiece, and how you can use open source software to do the same thing.

In this lightning talk, let's delve into the details about how you can create your own charts for a right stitchup.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Tuesday/A_right_stitchup.webm 
122. Wednesday Welcome
Bruce Crawley

Welcome to the third day of linux.conf.au 2018!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/Wednesday_Welcome.webm 
123. Keynote: Six Years Later, or Hey, did you ever get the source code to that thing in your heart?
Karen Sandler

In 2012 at LCA, Karen gave her first full length keynote talking about her pacemaker defibrillator, her journey to seek the source code on that device and her newfound passion for software freedom as fundamental for all of our critical technology. Now, six years later, Karen evaluates her efforts over the intervening time and assesses the current outlook for software in our hearts and everywhere.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/Welcome_and_Keynote_2_Karen_Sandler.webm 
124. I'm a cat


I'm a cat
 recording release: no  

125. History rhyming in the kernel community and beyond
Jonathan Corbet

"History never repeats itself, but it often rhymes" goes a quote often attributed to Mark Twain.  In this talk, Jonathan Corbet brings over 35 years of experience in the free-software development community to bear on the questions of how we got to where we are, and where we may be headed in the future.  We set out to change the world, and we succeeded beyond our wildest dreams.  So why are we not happier with what we got, and what does the past tell us about how we should be building a better future?
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/History_rhyming_in_the_kernel_community_and_beyond.webm 
126. Creating a Linux Powered Robot
Simon Lees

Often as software engineers / developers the first thing we do when we want to start a cool new project is start writing code. In reality what we should do is to take a step back and look at what the people who went before us have already done, open source software provides a wonderful platform to build cool things with very little effort by utilizing existing code. 

I will use the experiences and lessons I have learned from building a Linux powered robot to illustrate this, I will go through my design emphasizing the design decisions taken to further illustrate this point while also touching on other systems engineering concepts such as modular design and using open protocols to further allow reuse and changes.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/Creating_a_Linux_Powered_Robot.webm 
127. How to run Kubernetes on your spare hardware at home, and save the world
Angus Lees

For the last few decades, the "Open Source Software" we hack on at work has been slowly evolving thanks to increased scale, distributed computing, and Cloudy McCloud.  Meanwhile, the "Free Software" we hack on at home has mostly stayed in the 1990's with stdin/stdout, writing to local files, and home directories.  This divergence has flow-on effects everywhere, such as shifting license choices for major building blocks, increased use of centralised free-as-in-beer services, and less support for federation and standardised network protocols.

Despite this, all the same pressures driving corporate changes _also_ apply at home, just at smaller scale.
This talk will demonstrate how easy it is to build and maintain an elastic, fault-tolerant *home* Kubernetes cluster out of spare hardware.  We walk through what the machine lifecycle looks like and how to solve typical home tasks like interactive shell accounts, printing or other network services, and periodic background jobs.

By the end you will be convinced of not just the practical but also the strategic reasons to modernise your home computing environment.  Join us in this nascent "garage cloud" movement, and help to build the Linux distribution for the *next* 30 years!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/How_to_run_Kubernetes_on_your_spare_hardware_at_home_and_save_the_world.webm 
128. Getting Started with MicroPython
Nick Moore

MicroPython is a Python3 for resource constrained systems, allowing you to develop IoT software in a pleasant high-level language and run it on a cheap microcontroller.

We'll look at:

* installing MicroPython on ESP8266 and ESP32
* inputs and outputs
* networking
* multiprocessing
* building MicroPython from source
* contributing to MicroPython

You'll need something to run MicroPython on. If you made your own LoliBot at the Open Hardware Miniconf, bring that, otherwise we have a limited number of ESP8266 modules available to purchase as part of your LCA ticket (under "extras").  Bring your own MicroUSB cable!

More information at: https://github.com/nickzoic/mpy-tut/
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Wednesday/Getting_Started_with_MicroPython.webm 
129. Everyone gets a pony!
Kristoffer Grönlund

This talk is either a free horse giveaway, or a talk about a programming language called Pony.

Memory safety in low-level programming languages is a topic that has received a lot of attention in the last few years, with languages like Rust, Julia and Swift that promise high performance and low runtime overhead coupled with a safer memory model than the "you're on your own" model of C and C++.

Pony is a programming language which draws inspiration from a wide variety of existing languages like Erlang, C and Python while at the same time incorporating some recent academic language research in the form of capability-based security. The resulting language compiles to native code, is compatible with C, highly concurrent and at the same time type safe, memory safe and data-race free. Most importantly, it is a joy to use!

In this talk I will provide an introduction to Pony together with some examples of what it looks like, and also give my own personal reasons for being interested in yet another new programming language.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/Everyone_gets_a_pony.webm 
130. Linux, Cosmic Rays and Art Installations
Paul Schulz

A distributed cosmic ray detector was built and installed as part of the Splash Adelaide 2017 Winter Festival. Situated on the banks of the Torrens River in Adelaide, the 16 individual sensors would
flash and emit sounds as muons were detected from cosmic ray showers in the atmosphere.

In this talk we will describe the project and the software written to run on the Raspberry Pi Zero
computer in each detector.

The Raspberry Pi Zero runs Raspbian Linux and uses the WiringPi library to interface with signals
received from the detector hardware. Ansible is used deploy updates to the wirelessly networked array.

Code to run your own sensor is available on GitHub: https://github.com/PaulSchulz/cosmic-array.git
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/Linux_Cosmic_Rays_and_Art_Installations.webm 
131. Lessons from three years of volunteering to teach students code
David Tulloh

There has been a fair bit of discussion over the last few years on IT in schools.

Having spent three years volunteering at my local high school trying to force good coding practice on students I'm going to share the kind of war stories that teachers normally keep to themselves.

* The fantastic network engineering skills of students with a firewall between them and youtube.
* Managing illiterate students in a self driven learning environment.
* The fantastic manipulative skills of students determined to get somebody else to do the work for them.

On a more serious note we will also discuss:

* Time poor teachers and the shortcuts taken.
* Programming environments designed for school students.
* Big business in the classroom.
* Difficulties in encouraging girls to choose IT electives.

And finally why students are learning XML, CSV and project management but not OOP, automated testing or version control.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/Lessons_from_three_years_of_volunteering_to_teach_students_code.webm 
132. More crazy flying machines - CanberraUAV and ArduPilot
Andrew Tridgell

This talk will discuss the ups and downs (including a spectacular helicopter crash!) of the successful 2016 Outback Challenge entry by the CanberraUAV team. We're delighted to note that most teams in the OBC now run ArduPilot, but the challenge is living up to its reputation as a tough nut to crack.
I will also introduce some notable new aircraft designs, including my personal favourite, the TVBS (thrust vectored belly sitter).
Central to the OBC was communications, with the requirement for reliable beyond visual range communications a real challenge in a rural environment. The flight logs of our 2016 challenge flights show some rather surprising results with telstra and optus 3G modems, with communications lag far beyond what was expected. The highly redundant network system we used in CanberraUAV was very complex, but proved its worth on the day after our relay aircraft was destroyed.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/More_crazy_flying_machines_CanberraUAV_and_ArduPilot.webm 
133. (re)implementing (Google) maglev in Rust
Robert Collins

A war story: Developer re-implements a Google whitepaper in Rust using netmap for networking.

In 2016 Google released a whitepaper about their small packet wire rate - 40Gbps even, highly available IP load balancer. I happened to have some weeks shortly after that happened where I was able to do whatever I wanted... and I decided to have some fun and implement an open source look-alike.

Maglev has some distinctive design choices - such as the use of userspace networking to achieve zero-copy forwarding - which I knew about but had not actively used, as well as doing direct server return - sending packets to backend servers wrapped in GRE, but traffic in the other direction is routed directly, so the traffic pattern is asymmetric.

Since I was young and foolish then, I thought it would be good to also deepen my knowledge of the Rust language at the same time... and develop it on my not-as-Linux-friendly-as-I'd-like Surface : so my Linux
environment was actually a Hyper-V VM.

This combination led to discovering some truely fantastic facilities in Rust, bugs in the Linux kernel and the netmap project, and exploring some of the awkwardness where very clever C datastructures don't map well to Rust's ownership model.

The current status of the project is that the core use case works: traffic can be forwarded using network ring buffers, without needing a dedicated network card, routed with zerocopy while preserving GRE wrappers. Higher level facilities like dynamic reconfiguration and backend health signalling are not yet implemented (but are designed).

In the talk I will cover the choices I made and why - rust vs the world, netmap vs DPDK, things I found surprising about doing userspace networking, detail the gritty details of doing userspace networking with Netmap from Rust, using Rust to parse and create network packets, as well as driving netlink from within Rust. I'll cover the bugs I had to fix in order to write the code I wanted to write.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/reimplementing_Google_maglev_in_Rust.webm 
134. The Twisting, Turning, Narrow Road That Is Security
Casey Schaufler

The road to computer security can't be especially smooth or straight for us to have wound up where we are. Why are there so many start-up options in systemd? Why is CAP_SYS_ADMIN so broad, when CAP_CHOWN is so specific? Who came up with the "mask" in access control lists? Are namespaces a security feature, or not? How did SELinux get so complicated? How did we come up with all these peculiar behaviors?

Let a kernel programmer from the 1970's take you through some of the history, mindset and all too often politics that have created the security paradigms, facilities and features we know in Linux today. We'll cover a few things from before the epoch (1 January, 1970) and the early days of UNIX. There will be a bit about the American "Orange Book", and how "C2 in '92" drove a frenzy of security feature development. We'll discuss how that lead to the POSIX P1003.1e/2c DRAFT and it's implications for security features as well as how it created an early cooperative development mindset within the security community. The arrival of Linux and the internet introduce new opportunities. The emergence of Linux Security Modules and their disappointing impact gets mentioned, too. Of course, the move from open systems to open source is next. The move to isolation, using virtualization and namespaces and the inevitable discovery of containers comes next.

We wrap up with some predictions of direction and possible disappointments in the future.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/The_Twisting_Turning_Narrow_Road_That_Is_Security.webm 
135. Is the 370 the worst bus route in Sydney?
Katie Bell

In Switzerland, people will be surprised at a bus that's 2min late. In Sydney, people will only consider it noteworthy if a bus is more than 30min late, and this varies greatly between routes and providers. So, how do Sydney busses (and third-party bus providers) stack up against each other and the world? To answer these questions we need data… lots of data.

Hooray for open government data! Transport NSW publishes real-time information on the location and lateness of all public transport. Unfortunately it's ephemeral – there is no public log of historical lateness for us to analyse. To gather the data I needed I had to fetch, log and aggregate ephemeral real-time data that was never intended to be used this way. There are random gaps and spontaneous route or timetable changes for special events, roadworks or holidays. Even with noisy data, the patterns start to emerge across months.

Public transport networks of the world export timetable and real-time data in a (reasonably) consistent format so this process can be applied across cities and countries. Let's see how Sydney stacks up against other cities or how Australia stacks up against the world! Perhaps 40min late busses are not an inevitable fact of life.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/Is_the_370_the_worst_bus_route_in_Sydney.webm 
136. Practical hands-on accessibility testing
Nicolas Steenhout

Testing for web accessibility can feel daunting when you aren't used to it. But with the growing requirements for sites to meet accessibility guidelines, it has become an unescapable part of a developer's life. Accessibility should be seen as a challenge, rather than a chore. 

This workshop will demonstrate an accessibility testing workflow that can be integrated in coding workflow, and will include a review of automated testing, and hands-on manual testing using a variety of tools, from using the keyboard to using a screen reader application. We will work on real life sites, as well as some code snippets.

Participants will leave the workshop with a solid understanding of common accessibility barriers and methods to test for, and remediate, these barriers.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Wednesday/Practical_handson_accessibility_testing.webm 
137. What does the buyout of @arduino mean for #openhardware?
Kathy Giori

@KathyReid tweeted the title of this talk on July 29, 2017, a day after the Arduino buyout was announced. She was suggesting that the topic be submitted to #LCA2018. Having heard from a college friend that LCA is probably the best open source conference on the planet, I thought, why not provide my take?

I will share stories of Arduino (and Wiring Project) history, including the open licensing decisions that enabled its phenomenal organic growth, worldwide. Inhibitors to continued innovation occurred whenever key Arduino personnel attempted to restrict ecosystem participation (such as limiting microcontroller partners), or limit visibility of Arduino-compatible technology. Internal personnel feuds didn’t help either. It led to two years of lawsuits among co-founders, during which two different “Arduino” companies were vying for the trademark, to capture customer loyalty.

Even after a “settlement” was announced, with smiles and public handshakes shared on social media, the merged structure began with just a 3-person trademark holding company licensing the brand to the two feuding entities that continued to operate independently. They sold different boards, keeping their own profits, and keeping future projects and plans secret. Silicon vendors were confused, still dealing with two entities. To keep new products hidden, software wasn’t developed openly until the product was announced, vastly limiting expert review and collaboration that would have improved the quality, and reduced redundancy of new libraries, drivers, and core features. Similarly, an open and collaborative review of hardware designs, and cross-industry discussions for defining smaller “standard” form factors, was limited.

The buyout eliminates the “two Arduino” problem. But will the remaining Arduino team learn from the past and be more accepting of Arduino-compatible alternatives around them? Will the development process become more community-driven, allowing companies like TI to participate instead of feeling obligated to fork the IDE and roll their own? Will Arduino embrace and promote the great diversity of open source software options for programming the Wiring/Arduino framework, such as Snap! (Snap4Arduino), PlatformIO, embedXcode, and others? Will Arduino and compatible board designs remain open? 

I discovered my passion for the open hardware community while working at Qualcomm Atheros, and was already engaged in pushing upstream Linux development of the Atheros Wi-Fi drivers. I met one of the newcomers to Arduino hardware at CES, and supported him with the integration of the AR9331 into the Arduino Yun, the first board to bridge a microprocessor running embedded Linux (OpenWrt) with a microcontroller running the Wiring/Arduino framework. This led to me joining the Arduino.org team, where I forged strategic relationships with additional chip vendors, board manufacturers, and did outreach in education and professional IoT. Due to management issues, I had resigned just before the buyout announcement. But there are reasons to stay involved in the community. Take for example RISC-V -- with an open architecture processor, we’re on the verge of open software, open hardware, *and* open silicon. Come listen to my take on Arduino history and where I think #openhardware can go in the future.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/What_does_the_buyout_of_arduino_mean_for_openhardware.webm 
138. Make a bigger pie: Updating the partition count in a consistent hash ring
John Dickinson

Consistent hash rings are often used in distributed storage systems to efficiently compute data placement. However, for efficiency, these hash rings are often implemented with a fixed number of partitions of the key space. This is how OpenStack Swift's data placement algorithm works. Swift's "part power" is used to segment, or partition, the consistent hash ring used for placement. The part power is set when the ring is created, and it determines the upper limits of capacity in the cluster.

Unfortunately, if the partition count is set too high, there will be excessive overhead in the system and storage capacity will be underutilized. However, if it is set too low, then data placement will get "lumpy" and be unevenly distributed across the cluster. An operator is forced to balance these two concerns, often without knowing how much the cluster will grow.

Recently the Swift community has merged a feature that allows operators to increase the partition power in an existing cluster. This allows operators to set the part power to a low value when the cluster is created and increase it over time as the cluster expands. Implementing this feature is tricky, because the part power is a fundamental part of the data placement algorithm. Changing it can potentially make all of the data in the cluster completely inaccessible. Swift's implementation, however, is able to keep the cluster available during the entire process.

This talk will describe the data placement problem, explain how the community implemented the feature, and give a short demo of the feature in action.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/Make_a_bigger_pie_Updating_the_partition_count_in_a_consistent_hash_ring.webm 
139. Dealing with Contributor Overload
Holden Karau

The first external person contributing to our project is amazing, but when that 1 snowballs to 1,000 life can get a little bit stressful. All of these fine lovely people want to help, but somehow no one seems to want to help you deal with all of the code reviews, proposed documentation changes, or keeping your testing infrastructure alive (or three people want to help in different directions).

This talk explores what happens as a community grows using the speakers experience in her own personal projects (which have much less than 1k contributors) as well as larger projects, like Apache Spark.

Come for the being told its not your fault, stay for the techniques to avoid pissing everyone off.

P.S.

If the speaker is behind on reviewing one of your pull requests she is very sorry and would like to offer you a sticker and hope this talk explains some of why she is late.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/Dealing_with_Contributor_Overload.webm 
140. FOSS is Child's Play
Nicky Ringland, Amanda Hogan, Bruce Fuda

Australian students ranked last in tech skills and interest in technical jobs[1]. This isn't surprising: the typical IT experience for a school student involves Word, typing and Powerpoint. Compared to the experiences of contributors to the Open Source community, it is clear that a major intervention in schools is needed. 

The new Digital Technologies curriculum is this much needed intervention. From 2018, hundreds of thousands of students will be on their way to becoming programmers, hackers and makers, but only if their early experiences are positive.

The Australian Computing Academy has created 32 hours of free, open resources teaching FOSS languages such as Python and Arduino, and will create over 100 more! Through fun, engaging projects that connect to the real-world, we are developing CS skills and enthusiasm in every student. The first challenges are available now, exploring chatbots, musical instruments with embedded devices, and a throwback to old school computing education with Papert and Logo: generating vector graphics with the Python Turtle.

More capable students, skilled in and excited about the fundamentals of computer science, can make meaningful contributions to Open Source projects, learning both the philosophies and ethical principles of the FOSS community while also building a body of work that sets them up for a career in any field.

We're calling on everyone - developers, hackers, makers and educators - to make space for students in open source communities. Whether first contributor programs targeting young learners or working with us to make your project more accessible, but fostering new talent has always been a philosophy of the open source community. We’re making FOSS the new normal.

[1]  2016 report from the World Economic Forum across global sample of countries
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/FOSS_is_Childs_Play.webm 
141. XFS: Teaching an Old Dog Old Tricks
Dave Chinner

XFS has been in production for more than 20 years and has been in the linux
kernel for 15 of them - it is the oldest of the current mainstream
Linux filesystems. The design of XFS was state of the art in the late 1980s,
when btrees, extents and journalling were shiny new concepts. While development
of XFS still continues, it's design and architecture is largely unchanged. many
of the tricks that XFS brought to Linux can now be found in other Linux
filesystems, too. It's the old dog of the pack.

We recently introduced a late-90s technology to XFS: shared data extents and a
copy-on-write IO path. The copy-on-write tree structure that first appeared in
the late 90s can be found in ZFS and BTRFS, but not XFS. So while XFS can now
provide some data manipulations like clones and deduplication, it doesn't provide
any of the more advanced CoW functionality like snapshots that traditional CoW
filesystems inherently provide.

Given that XFS doesn't have a copy-on-write architecture, can we use the new
functionality to provide a similar feature set to native COW filesystems? What
other old tricks do we need to pull out of the bag to make this a reality? And
how much will the result look like XFS?

In this talk I'll outline my crazy plan to add filesystem management concepts to
XFS that only copy-on-write filesystems current provide to Linux users. There
won't be anything "new" here - I'll describe the old tech that inspired the
algorithms and structures that we'll use and, more importantly, some of the
pitfalls and hard lessons learned from the original implementations of these
techniques.

With any luck, I'll present a coherent story of how we are going to bring
subvolumes, snapshots, writeable clones, send/receive remote snapshot
replication, page cache sharing and more to XFS without needing to change it's
underlying 1980s architecture.  XFS may be an old dog, but there's still some
old tricks we can teach it to keep it shiny, new and relevant to users for years
to come.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/XFS_Teaching_an_Old_Dog_Old_Tricks.webm 
142. The Open Sourcing of Infrastructure
Elizabeth K. Joseph

In recent years we've been seeing a shift in how infrastructures are being managed with the help of open source tooling and infrastructure software.

Well over a decade ago the LAMP stack broke us free from proprietary infrastructure tooling. With subsequent the rise of open source configuration management systems, websites sprung up so that common configurations, like Puppet modules and Chef recipes, from these systems could be shared between organizations using them in production.

Today, following a rush to cloud, companies are now looking for open source tooling to build cloud-like environments in their own new data centers. Technologies like OpenStack and DC/OS, powered by Apache Mesos, are allowing them to replicate much of the functionality that was previously only available with proprietary, hosted solutions. Taking this one step further, several open source projects and organizations have begun full-scale open sourcing of their infrastructures, allowing other organizations to directly benefit from their Continuous Integration tooling and more. Complete infrastructures have now become open source projects unto themselves, and operations engineers becoming more experienced open source contributors, alongside their developer colleagues.

Join me in look back through the history of why we chose to go with open source, and what it can teach us today as we evaluate building our applications against cloud platforms, APIs and more. I'll explore what questions should be asked before selecting a platform, some of the open source options available, and share examples of what organizations have gained by being very open about how they've built their infrastructure.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/The_Open_Sourcing_of_Infrastructure.webm 
143. Open Source in the FIRST Robotics Competition
David Vo

There’s no better way of getting people interested in STEM fields than cool outreach programs, especially high school outreach programs.

The FIRST Robotics Competition (FRC) is one of these important high school outreach programs.  This talk will explore what FRC involves, the role that open source plays within FRC, and the various open source communities built around FRC.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/Open_Source_in_the_FIRST_Robotics_Competition.webm 
144. Should you rewrite in Rust?
E. Dunham

When coders hear about a promising programming language, they often think "I'd like to write something in that!" While rewriting an existing utility or codebase in a new language can sometimes be a good idea, there are many situations in which it's not -- and to make it even more difficult, the benefits and drawbacks of a rewrite vary greatly based on which languages you're using! 

Come to this talk to learn about the various techniques you can use to integrate Rust with existing code in other languages, their pros and cons, and who's using them in the industry. Even if you haven't tried Rust yet, you'll get a crash course in its strengths, its weaknesses, and the many ways you can make it do cool stuff.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/Should_you_rewrite_in_Rust.webm 
145. A Brief History of I/O
Benno Rice

Whether it’s video and keyboards, disks and network interfaces, or touch screens and cellular modems all computers do some form of input and output. The ways in which I/O happens have changed massively over the years though.

On the hardware side we’ve gone from paper tape to punch cards to tape to many generations of hard drives and now various forms of solid-state storage. We’ve also gone from serial lines and modems to 2.5Mbps Ethernet all the way up to 100Gbps and beyond not to mention Wi-Fi. On the software side there have been many different ways to communicate with the POSIX file APIs and Berkeley socket APIs looming over much of it.

This session will give you an overview of historical hardware I/O mechanisms and how they’ve evolved into the mechanisms we have today. It will also look at the software side of things starting with mainframe I/O mechanisms and looking at the progression from there to the modern POSIX APIs. Lastly it will look at some of the ways I/O is changing and what the future of I/O may hold.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/A_Brief_History_of_IO.webm 
146. What happens when you quit your day job to work on OSS
Andrew Cooks

Who doesn't dream of being a hero who makes a real difference and puts a ding in the world with an free/open source project? Few people get the opportunity to try that and even fewer are mad enough to tell the world about how they took the leap and failed.

This talk is about my year of pursuing a business that not only relies on free/open source software, but one that creates free, open software in a transparent and collaborative way. My presentation is aimed at technical people who are curious about, or considering starting a business. It covers some of the lessons learned from bootstrapping a new self-sufficient free/open source project.

In this talk I'll cover:
* What compelled me to do this and what was 'the problem to solve'?
* How did I expect to earn income?
* When and why did I quit my day job? (how to distinguish between a hobby project and a business)
* Is there a conflict between community-building and profit-seeking?
* How can we mitigate the risk and burden of IP, copyright and all that jazz and get back to solving technical problems?
* How do you know who your customers are? (Your itch is not everyone else's itch.)
* What kind of financial planning and support made this possible and could I try again?
* Where did I find help?
* What did a typical day look like?
* What were some of the main challenges and obstacles I faced?
* Who do I look to for inspiration and examples of success?
* Is going solo complete madness? Did I have to wear my underpants on the outside?
* When/why did I stop and go back to a day job?
* How did this project make me a more attractive employee?
* What is it like to be an employee again?
* Would I do it again or would I recommend it to anyone else?

The aim of this presentation is to offer encouragement and to point out potential pitfalls of starting an open source software business. However, this talk should not be taken as business advice.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/What_happens_when_you_quit_your_day_job_to_work_on_OSS.webm 
147. Can your diff(1) do this?! Improving software review & QA with diffoscope
Chris Lamb

In an age increasingly concerned with reducing bugs as well as complying with free software licenses, it is vitally important to thoroughly review audit any changes to the software that powers our technology and infrastructure.

However, existing tools to perform comparisons between two versions of a software package are overly-blunt instruments, either providing too much output or none at all. Binaries such as firmware images or precompiled executables are especially problematic: a single change in the source is presented as a meaningless stream of changes, offering no insight into potentially critical bugs. And these are often precisely the files we care most about…!

Diffoscope is different. Developed as part of the Reproducible Builds effort, it gets to the bottom of what makes files truly different. It recursively unpacks archives of all kinds and transforms various formats into human-readable forms for display. It can compare two tarballs, ISO images, PDFs, Microsoft Word documents, etc. just as easily.

This talk explains the varied and practical usages of diffoscope and how this flexible "diff on steroids" is a long-overdue & fun tool for anyone writing or releasing software today.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/Can_your_diff1_do_this_Improving_software_review_QA_with_diffoscope.webm 
148. Using GStreamer
Jan Schmidt

The GStreamer framework is a widely used and comprehensive multimedia processing system. It works cross-platform on Linux, MacOS, Android, Windows and iOS. The flexibility of its pipeline model caters for a very large number of use cases.

This tutorial is about how GStreamer works to process multimedia, and how to harness it for various tasks.

This tutorial will provide:
* An introduction to GStreamer terms, usage and the GStreamer pipeline model.
* An overview of a few of the many places GStreamer is used
* How to build your own GStreamer pipelines for playing, converting, editing and streaming media.
* Look at the requirements for various types of processing elements: Data sources, sinks, filters, converters.
* Using GStreamer in applications for custom processing and manipulation of data flow.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Wednesday/Using_GStreamer.webm 
149. Freedom Embedded: Devices that Respect Users and Communities
John Sullivan

GNU and Linux are now embedded in more kinds of hardware than ever, but nearly always only by requiring proprietary bits. The world’s most popular tablets and phones are based on a free core system loaded with nonfree software on top. We are at risk of free software being used primarily as a delivery vehicle to lower the cost of getting proprietary products to market.

How do we get the freedom we all want, and what is the market for that? The Free Software Foundation has a certification program called “Respects Your Freedom” (RYF) that awards a certification mark to hardware meeting a set of free software standards (fsf.org/ryf). 

RYF has already made significant gains, especially over the last few years, certifying USB wifi adapters, 3D printers, home wifi routers, and earlier generation laptops. A growing number of small companies are competing on the basis of the certification, and crowdfunding campaigns are citing meeting the standards as a key project goal.

Bigger things are planned, and the program needs to scale to meet the demand it's discovered. Get updates on what’s in store, learn what it takes to get your product certified, hear about the impact of certification so far and the community that has formed around the program, and discuss possible improvements to the standards.

Can we turn our current “free software invisible under the hood” reality into a reality where consumers can go into a store or shop online and find clearly marked products that fully respect their freedom?
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/Freedom_Embedded_Devices_that_Respect_Users_and_Communities_2.webm 
150. Next Generation Config Mgmt: Reactive Systems
James Shubin

Mgmt is a next gen config management tool that takes a fresh look at existing automation problems.

Three of the main design features of the tool include:
* Parallel execution
* Event driven mechanism
* Distributed architecture

The tool has two main parts: the engine, and the language.
This presentation will demo both and include many interactive examples showing you how to build reactive, autonomous, real-time systems.
Finally we'll talk about some of the future designs we're planning and make it easy for new users to get involved and help shape the project.

A number of blog posts on the subject are available. https://ttboj.wordpress.com/?s=mgmtconfig Attendees are encouraged to read some before the talk if they want a preview!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/Next_Generation_Config_Mgmt_Reactive_Systems.webm 
151. Securing the Linux boot process
Matthew Garrett

Linux has had support for UEFI Secure Boot for some time, which helps secure part of the boot process - you can be reasonably sure that nobody's replaced your bootloader or kernel, and that's sufficient to cover a bunch of cases. But for various technical reasons there's still a number of security critical components that are entirely unverified and which can be replaced by an attacker, and that means anyone with access to your system can configure it to steal (say) your hard drive encryption password. That's suboptimal.

There are various solutions to this involving TPMs, but so far they've all involved a lot of manual configuration and run the risk of being locked out of your machine for upgrading your kernel at the wrong time. Surely we can do better?

Unsurprisingly, yes. This presentation will describe some light modifications to the way distributions ship components that will make it possible to ensure that systems boot without running the risk of sensitive credentials being stolen but also without compromising the flexibility of the existing Linux boot process.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/Securing_the_Linux_boot_process.webm 
152. Creating open data about Australia’s local councillors: Our Outreachy Internship 2017
Hisayo Horie, Luke Bacon

This is the story of the first Outreachy Internship to work on an Australian Free Software project.

Outreachy Internships are a way for newcomers from underrepresented backgrounds to get experience contributing to free and open source software projects by doing paid, full-time work. The attendees of LCA 2017 raised over $20,000 to fund Outreachy Internships, and this was the first one!

In 2016 the OpenAustralia Foundation built a system for you to have an open exchange with your local councillors about planning applications in your area.  As usual, there's no useful, comprehensive open data about local councillors that can be used to run a system like this—so we created it.  But there's too many councils for the OpenAustralia Foundation’s tiny team to maintain this data. This is a common problem for civic tech projects around the world.

In their Outreachy internship, Hisayo Horie build a tool for people all over Australia to keep the records for their local area up-to-date and contribute it as open data. This means the system the OpenAustralia Foundation built can actually get used, and the data can come from the people who actually use it.

Hear from Hisayo and Luke Bacon (OAF) about the Outreachy experience and their process of collaborating on civic technology across time-zones.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/Creating_open_data_about_Australias_local_councillors_Our_Outreachy_Internship_2017.webm 
153. Extending C++ With Python (A Brief Odyssey)
Tim Serong

When the words "Python", "C++", "extension" and "module" appear in the same sentence, it's usually because someone is talking about a Python application which uses a C++ extension module, maybe for performance reasons.

What if, instead, you want to extend a C++ application by writing Python modules?  It turns out that's actually possible, by using the Python/C APIs to embed a Python interpreter in your application.  But it's not very well documented.

Come with me on a journey into the wonderful world of sub-interpreters, thread states, reference counting and irritating conflicts between global objects that expect to exist only once.

Along the way we'll battle unexpected deadlocks, untangle contradictory documentation, and find that there are some things that cannot be safely killed.

By the end of this adventure, you will have learned more than you ever wanted to know about pieces of the Python interpreter you never knew existed.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Wednesday/Extending_C_With_Python_A_Brief_Odyssey.webm 
154. Future Technological Directions in Bitcoin
Rusty Russell

Bitcoin has no such reliable record like LWN (and a huge number of unreliable ones!), so it's near-impossible to keep up with the flow of ideas from prototypes, academic research and development into the Bitcoin ecosystem.

From outside it may seem like nothing is happening, but it's simply never been laid out in one place.  This talk delivers hard-won insight based on years of working with core developers and coders which you won't get anywhere else, and is delivered by someone passionate about the technology and uninterested in the drama.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Wednesday/Future_Technological_Directions_in_Bitcoin.webm 
155. Challenges and discoveries bringing open source software to the PowerPC64LE world.
Leonardo Bianconi

PowerPC64 little-endian mode was introduced with POWER8 system family, making it easier to port x86_64 applications to it. This is the main target of technologies provided by OpenPOWER Foundation, which is a collaboration for Power Architecture products.

This talk will show the biggest challenges found to port a software initially designed to x86_64 architecture, and what were the solutions adopted, beyond expose some differences between both architectures. Some topics are:

 * How to handle the frame differences.
 * Push/Pop values dynamically in a PPC64 frame.
 * Adapting assembly memory operations.
 * Using TOC (Table Of Contents) as an amazing tool.

HHVM, which is the main target of this talk, is a PHP interpreter built by Facebook, which implements the JIT (Just-In-Time) compilation technique to dynamically translate part of itself into assembly code, making its execution faster.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Wednesday/Challenges_and_discoveries_bringing_open_source_software_to_the_PowerPC64LE_world.webm 
156. Open data for political and financial transparency
Rosie Williams

There is a lot of hubris about the benefits of open data. Most people want improved financial and political transparency (support for a Federal ICAC confirms this) however political and policy change often arises only after a scandal which has come about as the result of insider whistleblowing rather than access to public facing information. The Panama Papers exemplifies the role of whistleblowers in creating policy window events. 

This talk will overview the available open datasets relating to financial and political transparency published by government agencies using a live data transparency project, what can be done with existing datasets and the data quality issues that impact their usability.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Wednesday/Open_data_for_political_and_financial_transparency.webm 
157. Taking license compatibility semi-seriously
Richard Fontana

License compatibility refers to the problem of creating combined works out of code under different, seemingly clashing open source licenses. It most often arises where at least one of the licenses is in the GPL family.

A surprising amount of intellectual energy, by developers, users, lawyers and "compliance professionals", has been devoted to dealing with the topic of license compatibility. Incompatibility is often spoken of as a significant open source compliance issue. But there has been very little critical analysis of the assumptions behind received wisdom about license compatibility. Where such analysis occurs, it seems to have little to do with the real-world behavior of developers and projects.

This talk attempts to make some sense out of the topic of license compatibility, noting where it makes sense and where it doesn't. We'll discuss some interesting historical and contemporary cases, like ZFS and Linux. The talk will propose ways of adjusting how we think about license interpretation so that compatibility doctrine is on more solid ground and in line with the realities of community development.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Wednesday/Taking_license_compatibility_semiseriously_2.webm 
158. Thursday Welcome
Bruce Crawley

Welcome to the fourth day of linux.conf.au 2018!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Thursday_Welcome.webm 
159. Keynote: Wandering through the Commons
Hugh Blemings

Reflections on Free and Open Source Software/Open Hardware in Australia, New Zealand and beyond. A keynote in three parts.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Housekeeping_and_Keynote_3_Hugh_Blemings.webm 
160. OpenMRS stories: saving lives with open source
Cintia Del Rio

Write code, save lives. 
With this motto, OpenMRS (Open Medical Record System) was created in 2004 with the goal to provide a free and open source medical record system platform, designed specifically for developing countries and low-resources healthcare providers. 

From small clinics, big hospitals, national health programs and anything in between, this project you probably haven't heard before is present in several different countries, and it has had an impact in public global healthcare. 

Join us in this talk to hear how lives were impacted by OpenMRS. From helping fight the latest Ebola outbreak to tracking multi-drug-resistant tuberculosis in Peru, you have the opportunity to learn how this open source project has been truly making a difference in the world.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/OpenMRS_stories_saving_lives_with_open_source.webm 
161. Signal Analysis with Open Source Logic Analysers
Alastair D'Silva

Hardware hacking often involves communicating with devices that do not have an existing library, or where the library does not implement features of the device that you require. The typical solution to this is that you grab the reference manual for the device, and develop software to achieve what you want. The question is, how do you debug your library when things go wrong? A key component of the debug process is looking at the signals going to the device and confirming that they are what you expect.

This workshop provides the user with some basic hardware, and walks them through using the supplied logic analyser to debug a deliberately flawed library.

Prerequisites:
A basic understanding of C/C++. You won't need to write new code, but you should be able to understand and make changes to existing code.
How to use a breadboard for electronic prototyping. If you haven't used a breadboard before, you can read up on how to use them on Adafruit, paying attention to how they are internally wired: https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard
An understanding of the 1Wire protocol. If you are not familiar with in, this tutorial provides a good description (flash required): https://www.maximintegrated.com/en/products/1-wire/flash/overview/
A laptop capable of running STLink and Pulseview. Setup instructions for both Windows and Linux are provided. Contributions for OSX are welcome. A minimum of 3 USB ports are required to complete this workshop easily, or 2 with a lot of port swapping. If your laptop has less than 3 available ports, a USB hub is strongly recommended.

A $35 hardware kit is required to complete this workshop, which you can take home afterwards. It includes an ARM developer board, SWD programmer, 1wire device and logic analyser.

A total of 50 kits are available. To reserve a seat in the workshop and a hardware kit, please add your name here: https://goo.gl/WGH2rz

Attendees must have cloned the tutorial git repository and completed the included prerequisites before the start of the workshop: https://github.com/InfernoEmbedded/logicanalyser_workshop


Objectives:
- Program an ARM microcontroller using an SWD programmer
- Read output from the microcontroller's serial port
- Learn the basics of the 1Wire protocol
- Use Sigrok to analyse the signal between the microcontroller and the device
- Use Sigrok for higher level protocol analysis
- Use Sigrok to debug device communications
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Thursday/Signal_Analysis_with_Open_Source_Logic_Analysers.webm 
162. The long and winding road to 10 Gigabit + in the Home Network
Joel Wirāmu Pauling

100 Base T was introduced in 1995 and it took only a few years for it to displace 10Mbit NICs and switches completely in consumer and business networks. Likewise 1000 Base-* was introduced in 1999 as a standard and since 2008 has been the De-facto choice of Wired Network Interfaces in consumer and home networks and associated devices.
More than a decade on, the humble Gigabit interface is still the fastest standardized port available to interconnect Consumer Equipment by and large.
10Gbit networks in the Datacentre have been the go-to server choice for some time - and QSFP28+ 100GBit is now starting to dominate the DC. Why haven't these technologies made it into Laptops and Desktops around the globe?
What options do you actually have for faster than 1GBit connections away from expensive enterprise situations?

This talk will cover the spectrum of options, performance tests, quirks and caveats relating to these questions. Including a focus on Thunderbolt3 kernel patches, USB3.0 and why the leap from 1000mbit to 10000mbit and beyond is taking so damn long.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/The_long_and_winding_road_to_10_Gigabit_in_the_Home_Network.webm 
163. Panel: Meltdown, Spectre, and the free-software community
Jonathan Corbet, Andrew 'bunnie' Huang, Benno Rice, Jess Frazelle, Katie McLaughlin, Kees Cook

The Meltdown and Spectre vulnerabilities raise a lot of questions about how our hardware works — and how we respond when things go wrong.  This panel will discuss these vulnerabilities, how they affected us, and what we would like to see done differently the next time around.  The panel consists of Kees Cook, Andrew 'bunnie' Huang, Jessie Frazelle, Katie McLaughlin and Benno Rice; it will be moderated by Jonathan Corbet.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Panel_Meltdown_Spectre_and_the_freesoftware_community.webm 
164. The Meson Build System - 4+ years of work to become an overnight success
Jussi Pakkanen

In the last year many core projects in the Linux ecosystem have transitioned to use the Meson build system. These include the X.org and Wayland graphical servers, the GStreamer multimedia framework, many GNOME projects and even systemd. Without fail these project report that the change has brought about many improvements such as reduced compile times and increased agility, easier to understand build definitions and, perhaps most importantly, increased developer happiness.

In this talk we shall be looking into the design and features of Meson and how they improve the day-to-day developer experience. These improvements are undeniable and noticeable but it turns out that selling them to people was a lot tougher than it first seems. We shall go through the history of Meson and talk about the all the hidden work behind the scenes that needed to be done before projects were willing to transition off their tried and true build systems to the new shiny.

The presentation concludes by looking at new features that are in the pipeline and other new things we should expect from Meson in the future.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/The_Meson_Build_System_4_years_of_work_to_become_an_overnight_success.webm 
165. micro-Linux init (PID1) in Golang
Sven Dowideit

A short journey from Boot2Docker, RancherOS, via LinuxKit to u-root

Containers need a host and an OS on which they run. Even "Server-less"
RancherOS was created from the idea that everything could be a container - so it has a System container service, and once enough system services have started, starts up a "User Docker" container.
In this talk, I'll be discussing the fun of writing a "simple" Linux init process, which uses cloud-init and container composition to bootstrap the OS, and the user's containers.
And then, I'll move onto a new simpler project - u-root.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/RancherOS_a_golang_init_for_containerized_services.webm 
166. Robotica - Robot maid for assisting with autistic kids
Brian May

Dealing with an autistic child can be a challenge. Even more so for twins. I invented Robotica to try and help with some of the challenges at keeping a fixed routine. Robotica is a maid from Duck Tales, and at first she scares the kids. Robotica improves over time. In my house, Robotica is installed on several Raspberry Pis around the house, and has a asyncio based scheduler system. At designated times, Robotica will give voice messages, play music and/or adjust the LIFX lights. An added challenge is to deal with numerous exceptions for the normal routine without having to manually adjust the schedule on a daily basis. There are lots of things that I have planned, but only one me to do them all. The purpose of this talk is to attempt to get other people interested in developing Robotica so that it can be more useful to more people.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/Robotica_Robot_maid_for_assisting_with_autistic_kids.webm 
167. What is the most common street name in Australia?
Rachel Bunder

Finding the most common street name in Australia may sound relatively simple, but it quickly leads to other questions. What is a street name? Do The Avenue, The Grand Parade and The Serpentine all share the same name? And what is a street? Is the M5 Motorway a street? What about M5 Motorway Offramp?

This talk will answer these questions using Open Street Map (OSM) data. We'll be having a look at what OSM is and how we can use it. We will discuss what different methods for defining streets and street names. And finding out what the most common street name in Australia is.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Thursday/What_is_the_most_common_street_name_in_Australia.webm 
168. Making Technology More Inclusive Through Papercraft and Sound
Andrew 'bunnie' Huang

The participation of women in computer education is low; undergraduate enrollment hovers between 10-20% female globally. The picture at the primary school level is fuzzier, as students do not declare majors at that level, but evidence indicates the trend starts from a young age. Can we make computer education more gender-inclusive? Presenting technology in familiar, non-threatening contexts can lead to more balanced gender participation. For example, Chibitronics uses the context of papercraft to present electronics to beginners; the familiarity of papercraft improves the participation of women of all ages in the creation of electronics. 

Based on these learnings, we have devised the “Love to Code” platform, an open source hardware-to-cloud stack which combines the familiarity of paper craft with a web-based, driver-free embedded firmware development environment based on FSK audio provisioning via a headphone jack. In this talk, we will dive into the novel open source technical contributions of this platform, which includes the audio-based provisioning protocol and the unique rigid-flex design of the circuitry enabling papercraft integration, as well as the multi-threaded client OS and cloud infrastructure required to complete the picture. This combination of new technology with familiar interfaces aims to lower the barrier to computer education, thus making coding a more accessible and inclusive activity.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Making_Technology_More_Inclusive_Through_Papercraft_and_Sound.webm 
169. Building a Better Thermostat
Matthew Treinish

After returning from a recent trip that occurred during the middle of a heat wave. I arrived home to find my apartment quite hot, at least 45C inside. Needless to say it wasn’t the most comfortable way to come home after 15 days out of town, I decided it was time for me to do something about it to address this so I didn't come home to that unpleasant surprise again. Normally, this problem is solved by having a thermostat which controls the air conditioning. However, my apartment did not have a thermostat. So I decided to build one using open source software.

This talk will cover how I went about solving my problem using existing software and protocols like home-assistant, MQTT, and also some new software that was created for this. It'll also discuss how using open software and home automation I was able to solve my issue but also make cooling my apartment smarter.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/Building_a_Better_Thermostat.webm 
170. Rust Programming Techniques
Nicholas Cameron

Rust is a language for fearless systems programming. It offers memory safety, data race freedom, and a modern programming environment, without sacrificing low-level control over performance and memory usage.

Learning a new programming language is hard. Even after mastering the syntax and type system, learning the libraries and techniques can take years. If you've read or written Rust and want to improve, this talk will give you a turbo boost! This will be a very practical tutorial, aimed at taking your Rust programming to the next level. We'll teach some core Rust design principles by covering a few key topics in depth. This tutorial is aimed at those with some Rust experience, but if you're a total beginner, you'll still learn a lot about what Rust programming is like in practice.

The tutorial will start with programming 'in the small': we'll explore some key library types (Option, Result, and Iterator) and cover practical error handling. Putting these together we'll see how to structure your control flow to write clear, succinct programs. We'll then cover some larger-scale design issues - using ownership as a primary architectural principle, and abstraction using traits.

You'll learn how to be more productive in Rust by writing clean and idiomatic code. You'll learn to work with the language rather than fighting against it.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Thursday/Rust_Programming_Techniques.webm 
171. High performance science - open and reproducible neuroscience image processing that scales?
Steffen Bollmann

Today’s neuroscientific results are based on complex image analyses that involve a large variety of open source software. Unfortunately the last years have shown that many neuroscientific findings cannot be replicated and that data sets are not yet shared widely to enable efficient reuse of data and alternative analyses.
In this talk I want to give an overview of how the neuroscience field aims for open and reproducible analyses and by this enables better research and more reliable findings. I want to show how the field progressed to use open data formats for storing raw data acquired from MRI scanners (ISMRMRD), how processed images that can reach multiple TB in file size are stored, including data provenance information (MINC), and how these data are analysed in a reproducible way using software containers (SINGULARITY) that allow scaling an analysis from a small development platform to large scale high performance computing systems and enable the efficient managing of different software versions and the reproducibility of analyses. Finally, I want to touch on sharing neuro scientific data in open repositories that allow the re-use and pooling of large datasets to derive new results that would be impossible without data sharing.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/High_performance_science_open_and_reproducible_neuroscience_image_processing_that_scales.webm 
172. Personalisation at Scale: A “Cookie Cutter” Approach
Jim O'Halloran

In this talk I will explore a multifaceted approach for building high performance Magento sites, while still delivering personalised content.  How do you cache content for performance, yet still provide a personalised experience for visitors to your site?  In this talk we’re going to allow you to have your cake (or cookie :-) and eat it too.  The concepts and techniques have been successfully applied to large scale, high performance sites; but, while developed for Magento, they also apply to other eCommerce platforms and Content Management Systems.

I will discuss a technique called “cookie cutter” for personalising cached content.  This technique allows the use of a Full Page Cache (such as Varnish) for performance, while still allowing personalised content such as recently viewed product, name, or number of items in your cart to be included in the page.  Typical solutions to personalisation involve the use of Edge Side Includes (ESI), but there are limitations to that approach, so we’ll talk about ESI, and why “cookie cutter” can be a better solution.

What about cache misses?  A multifaceted approach to performance optimisation is required.  I’ll explore some tools, techniques and concepts we can use to improve performance; including an enhancement to the Magento block cache that can be implemented using Magento’s module extension mechanism..
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Thursday/Personalisation_at_Scale_A_Cookie_Cutter_Approach.webm 
173. Budget CNC machining
Ben Martin

Turning a budget $600 chinese 3040 CNC into a monster that eats 1/2 inch 6061 alloy for lunch. Why you shouldn't be intimidated by upgrading a CNC to run open firmware and be more capable and extend the software interface to the machine.

Along the way replace the controller which wanted a parallel port with a SmoothieBoard running open source firmware on a cortex-m microcontroller, build server software to allow MQTT machine control opening the door to MQTT remote controls and MQTT over WebSockets bootstrap web interfaces. The big gulp situation of one way butchering the original spindle mount when you upgrade to a 2.2kw, 24krpm cutter. The more advanced upgrades to completely replace the z axis assembly to gain more travel in the lead up to 4 and 5 axis machining.

Some might say that managing file lists and cut jobs with MQTT is a contortion of the technology, but if it's useful and it works then why not?
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/Budget_CNC_machining.webm 
174. Can RCU and CPU hotplug survive the attack of the killer virtual environments?
Paul E. McKenney

Virtualization was in use before most linux.conf.au attendees were born, in fact, virtualization was in existence before the speaker was in high school.  Furthermore, Linux has been running on hypervisors of various types for about 20 years.  So one might think that the Linux kernel would have long since completely adapted itself to the realities of virtualization.

One would be wrong.

Virtualization provides additional challenges to concurrent code, for example due to the hypervisor preempting "preempt-disabled" guest-OS code, and even preempting guest-OS code that is under the naive delusion that interrupts have been disabled.  Such preemption can amplify concurrency bugs, and such amplification becomes all the more destructive as people become comfortable with increasing levels of consolidation, resulting in higher CPU utilization and in turn higher probabilities and durations for hypervisor preemption.

This talk will look at a few RCU changes that virtualization has motivated and might motivate in the future.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Can_RCU_and_CPU_hotplug_survive_the_attack_of_the_killer_virtual_environments.webm 
175. F-Droid: The private, secure, free and open app store for Android
Peter Serwylo

While smartphones have been heralded as the coming of the next generation of communication and collaboration, they are a step backwards when it comes to personal security, anonymity and privacy.

Most app stores encroach on users freedoms by closely monitoring and profiling how people use their devices. They reject apps which do not align with their terms of service. They are also unavailable in some of the worlds biggest markets, such as China, due to being blocked by the Government.

F-Droid is the open source app store for Android focusing on freedom, privacy, and security.

It doesn't track what you search for, what you install install, or what apps you use. It warns you about apps which track you or show you ads. The main F-Droid repository gives you access to over 2000 open source apps, and there are other 3rd party repositories which expand this even further. In addition, it is essentially unblock-able, making it a vital piece of infrastructure for activists and journalists who need access to apps to facilitate secure communication.

Over the last year, the F-Droid project has completely revamped its UI to make it more friendly to non-tech users, adding support for screenshots, feature graphics, and localized metadata about apps. We have also added several new tools to make it easier for anybody to setup and run their own curated app store. This talk will cover the various aspects of the project, focussing on the client, its security model, and how it is being used to ensure everyone is able to access high quality open source apps as the smart phone revolution continues.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/FDroid_The_private_secure_free_and_open_app_store_for_Android.webm 
176. Typesafe CSS-in-JS
Luke John

Type systems are becoming increasingly popular in the javascript community with leading projects increasingly adopting flow and typescript.

Another awesome development in the javascript space has been the rise of css-in-js frameworks.

This talk is a deep dive into the challenges and opportunities that arise from typing css-in-js.

Luke is one of the leading contributors to the one of the leading css-in-js frameworks `glamorous`, and also is also a downstream consumer of these typings having helped lead it's adoption on Western Australias leading news websites.

The challenges and opportunities around typing javascript frameworks that this talk covers should be translatable any javascript and web frameworks.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Thursday/Typesafe_CSSinJS.webm 
177. Geographically distributed multi-master replication with PostgreSQL and BDR
Craig Ringer

Keeping your data in more than one place is vital for business continuity, and databases are no exception. Backups are great, but they won't help you when your normally-connected EU, US and Australian operations all want to continue operating during a major WAN outage. This is where multi-master replication systems come into their own - but they also come with often overlooked costs and downsides. Bi-Directional Replication (BDR) for PostgreSQL can help solve some users' availability challenges in a globally distributed environment... if it's applied correctly.

Multi-master is not magic high availability secret-sauce that can be applied to every problem, no matter what some major vendors' sales teams would like you to believe.

Learn about when to use - and not to use - multi-master replication in general, and BDR in particular. When is it better to stick to a single-master system with failover? If you do select a multi-master system, what kind is best for you? Do you need something partition- and latency-tolerant, or something tightly coupled and transparent? Shared-mostly or shared-nothing? These details will have a major impact on whether a given system architecture can meet your needs, and understanding them will help you set better requirements during a design and product selection process.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/Geographically_distributed_multimaster_replication_with_PostgreSQL_and_BDR.webm 
178. Tap On to Reverse Engineering
Michael Farrell

Since 2015, I've been working on reverse engineering different public transit smartcards around Australia, with the goal of producing open source software to be able to read and interpret them, any where, any time, without an internet connection or requiring registration of the card in the user's name.

The fruit of this labour has been Metrodroid, a single Android application that allows you to read many smartcards in use around Australia and the world.  I've written support for Sydney's Opal card, Manly Fast Ferry's smartcard, Brisbane's Go card, Canberra's MyWay card, Perth's Smartrider card, and Tasmania's Greencard, as well as a couple of overseas cards -- Hong Kong's Octopus card and Los Angeles' TAP card.

Along the way, I learned about RFID standards, its (lack of) security, analytics opportunities and privacy issues in smartcard ticketing, open data, and challenges resurrecting an open source project.

I will take the audience on a journey through these challenges to access, read and understand around 1 kilobyte of data stored in most people's wallets that is normally off-limits.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Tap_On_to_Reverse_Engineering.webm 
179. System Suspend Support in the Linux Kernel 2007 - 2017
Rafael Wysocki

System suspend is relatively straightforward from the user perspective.
When requested, it should put the whole system into a state with all
activity stopped and reduced power draw.  Next, the system should wait
in that state for an event to wake it up and then go back to its previous
state and get on with whatever it was doing before, ideally without any
side-effects visible to the user.  The implementation of that in an
Operating System, however, turns out to be seriously complicated.

First of all, stopping all activity in a multiprocessor system, like
a modern laptop, is a rather tricky business and it cannot take too
much time, or it will not be appreciated by users.  On top of that,
in general, all devices in the system need to be put into low-power
states, so that the total power draw of the suspended system can be
as low as expected and that should happen quickly too.  Still, some
devices need to remain sufficiently active to be able to wake up the
system when needed and that has to be taken into account along with
all of the possible dependencies between devices.  Moreover, the time
it takes for the system to get back to the working state also cannot be
too long and, finally, all of the above must be absolutely reliable
or system suspend will not be used.  Combined, all of these items
may look a bit intimidating.

Of course, that did not prevent Linux kernel developers from implementing
system suspend support, but it took quite some time to reach the current
state of the art.  Various parts of the suspend infrastructure have been
under development for several years, but it started to be recognized as
a separate feature in 2007.

Overall, a lot of progress has been made and nowadays system suspend
in Linux is regarded as one of the features that generally should work.
There are gaps in it and occasional regressions happen, but also there
is a huge number of Linux-based systems in the field that suspend
reliably on a very regular basis.  However, it is instructive and
somewhat entertaining to look back at where we started and how we
have got where we are today.

That leads to some interesting observations.  One of them, which seems to
be particularly important to me, is that improvements are made by iterating
three basic steps again and again.  First, we get some better understanding
of what really happens, either by diagnosing reported issue or by adding
support for new technologies.  That better understanding results in code
improvements which typically unlock some use cases that were not viable
previously.  Next, the new use cases are exercised and become the source
of feedback which then causes our understanding of things to get better
still and a new cycle begins.  Every iteration takes us to the next level
and progress is made this way.

That pattern is clearly visible in the history of the development of
system suspend support in Linux, but it is not the only thought-provoking
aspect of it as I will show in my presentation.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/System_Suspend_Support_in_the_Linux_Kernel_2007_2017.webm 
180. Mirror, mirror, on the wall: testing Conway’s Law in open source communities
Lindsay Holmwood

Mirror, mirror, on the wall: testing Conway’s Law in open source communities.

You’re probably familiar with Conway’s Law, that “organizations which design systems ... are constrained to produce designs which are copies of the communication structures of these organizations." But did you know that there’s a tradition in academia spanning as far back as the 1960’s that has studied it in action?  

Our understanding began in the traditions of organisational design, product design, and organisations-as-complex-systems. Conway’s Law is a separate tradition in technology, embracing our idioms and ways of storytelling.  

But all three traditions point back to the same underlying concepts. 

Conway’s Law has been studied across auto, aviation, software, banking, and healthcare. Each study has revealed how humans organise to build systems, and how those systems influence how we organise ourselves.

The results are not what you’d expect.

The internet has completely changed how we communicate – the cost of communication is lower than ever. Open Source breaks new ground about how we organise ourselves when working together.   How Conway’s Law applies to open source development will surprise you. 
  
People who attend this talk will learn:
  
* A brief history of Conway’s Law in management literature and academia.
* How Conway’s Law applies differently to your open source community and your workplace.
* How to apply the evidence to help you grow and sustain your community in a fast evolving ecosystem.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/Mirror_mirror_on_the_wall_testing_Conways_Law_in_open_source_communities.webm 
181. Aussie Add-ons: Liberating Australian catch-up TV with Open Source
Andy Botting, Glenn Guy

All of the major free-to-air Australian TV channels are providing on-demand catch-up TV streams, and some even provide access to live streaming, but access to these services requires using a web browser, mobile app or a supported proprietary smart TV.

In this talk, we present the Aussie Add-ons project (formerly known as XBMC Catch-up TV AU). This project aims to develop add-ons for the excellent Open Source Kodi Media Centre platform to support all the major free-to-air TV channels and others including AFL, NRL and Bigpond Video.

We will look into the history of the project, delve into some of the techniques used to reverse engineer streaming websites and mobile apps and look at some of the challenges we face, including DRM.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/Aussie_Addons_Liberating_Australian_catchup_TV_with_Open_Source.webm 
182. Burning Down the Castle
Daniel Vetter

My retrospective on 5 years of Linux kernel maintainership: Why the kernel community is a lot more broken than it looks, why maintainers benefit from that and why it's unlikely to change.

Just dissecting the gruesome workings of a broken community might be entertaining, but not all that enlightening. This talk will also look at how well-built communities, both large&small, avoid these pitfalls.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/Burning_Down_the_Castle.webm 
183. Elm by Example - Make beautiful map displays with Elm and Leaflet
Christopher Biggs

Maps and GIS are not scary.   You can build a responsive user interface 
that has custom map displays remarkably easily.

Most of us carry a geolocation device on us at all times.  This opens up
many applications for presenting information on a map.

The Elm environment (a functional programming language that transpiles to Javascript) leads to beautifully small and bug-free sites that also happen to be responsive and look great (particularly when combined with the Material Design toolkit).

Many people worry about being locked into the Elm language and unable to use other
javascript libraries.

This presentation will show how my team works almost exclusively in Elm, while still
having access to cutting-edge javascript toolkits such as Leaflet.js

Mapping gets everywhere, I find myself using geo-representation for applications
ranging from building management to vehicle traffic enforcement.

Come on in, the functions are fine.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Thursday/Elm_by_Example_Make_beautiful_map_displays_with_Elm_and_Leaflet.webm 
184. IPv6 and Containers: Why We Can't Have Nice Things (And How We Can)
Matt Palmer

Containers are everywhere.  And they all need IP addresses.  IPv6 has lots and lots of IP addresses.  It's a match made in heaven!  Despite this perfect match of problem and solution, however, there are a number of challenges that you'll face if you try to use IPv6 to address your containers.

With the benefit of having struggled (and mostly succeeded) to make containers and IPv6 play well together for the last two years, Matt Palmer has a lot of war stories and useful tips to make your journey to container networking nirvana a bit smoother.  He'll describe why things are the way they are, why they don't have to be that way, and how you, too, can experience the joys of never again having to configure a Docker port forward.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/IPv6_and_Containers_Why_We_Cant_Have_Nice_Things_And_How_We_Can.webm 
185. Inkscape for absolute beginners
Donna Benjamin

Inkscape is fun, powerful, free and open source software for creating scalable vector graphics. Its native file format, Scalable Vector Graphic (SVG) is a W3C open standard.

This in depth tutorial will give you the foundation skills you need to create simple graphics with Inkscape, and introduce the key concepts and terminology required to take your learning further.

Participants will undertake a series of tasks designed to introduce Inkscape's interface and tools for creating and modifying vector graphics.

Assumed knowledge: None.

New knowledge goals: Inkscape interface, creating shapes & lines, working with colour. Inkscape techniques, path operations, object manipulations. How to edit existing SVGs from wikimedia commons or openclipart.org

You don't need to be a designer, artistic or know how to draw. Just install Inkscape on your laptop, bring a mouse, come along and learn how to get the best out of this brilliant tool.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Thursday/Inkscape_for_absolute_beginners.webm 
186. Linux: the first second
Alison Chaiken

In 2013, the U.S. National Highway Transportation Safety
Administration proposed a new rule requiring a rear-view video camera
system for new cars.  The new regulation stipulated that passenger
vehicle cockpit displays should show detect hazards behind a vehicle
and be capable of producing video composited with warnings within 2
seconds of a driver placing the shifter into reverse.  Achieving this
goal was quite a challenge for a Linux system starting from a
powered-off state!  Carmakers who planned to ship Linux responded with
an all-out effort to understand the boot process and reduce the
time-to-video.  Those engineers who participated learned a great deal
about how Linux starts.

What does actually happen when the power button is pushed on a Linux
device?  What are initrd's, BIOSes and bootloaders, and why do we need
them?  There has been much controversy about PID 1 and SecureBoot, but
much less discussion about the work the kernel performs before
reaching userspace: probing devices, allocating memory and starting
per-core housekeeping threads.  The kernel actually does have a
main.c, but what's in it?  How does initialization of the kernel
compare to that of normal Linux processes, and how do normal processes
actually start anyway?  Kernel actions are sequenced via a series of
'initcall' stages.  Why do devices show multiple different boot
animations and screen resolutions?  How are 'suspend' and 'hibernate'
different?

The talk will lightly touch on topics like initialization of hardware,
how resume after hibernation differs from a fresh boot, what 'warm
boot' and 'cold boot' are, and x86_64 versus ARM initialization.  As
time permits, the talk will include simple demos of how to examine
your kernel with GDB, how to survive the rescue shell, how to build
your own initrd and why you might want to do so, and a few ways to
pass information between the kernel and the bootloader.

The technical level will be appropriate for system administrators and
developers who have some familiarity with installing Linux systems or
recovering them when they are stuck.  The talk will include brief
anecdotes from experiences during vehicular Linux development.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Linux_the_first_second.webm 
187. Sane Behaviour on Teeny Hardware
Seb Holzapfel

By necessity, embedded systems often use low power, cheap parts - which means that the device that flies your drone or keeps your heart beating is likely not to have a Memory Management Unit. This means that the usual protection provided by virtual memory against programming errors or untrustworthy code is absent - any task can access all memory.

Microcontroller designers recognised this problem and started to tack on a cheaper Memory Protection Unit instead. Memory partitions can be created by the programmer using the MPU to protect the kernel, real-time tasks and other data from each other - however using it effectively is not easy.

This talk will present how we implemented support for the MPU in ARM's Cortex-M series of microprocessors (a popular choice for low-power embedded designs) in eChronos, an open-source real-time operating system. It will explore how that support can be used to protect one task's data from another, the kernel from the payload tasks, and for other purposes - like sandboxing questionable third-party drivers. The implementation process was not straightforward - with many scrapped design prototypes, and traps for the unwary. Our experience represents an attempt to make the MPU usable without undue burden on the programmer using the system, and without compromising real-time properties. Other points in the design space will be discussed, along with our reasoning as to the implementation decisions we made.

A number of live hardware demonstrations (attempting to compromise MPU-less and MPU-protected systems) will be given throughout the talk.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Thursday/Sane_Behaviour_on_Teeny_Hardware.webm 
188. Developing NVM Express
Matthew Wilcox

Storage moves in cycles. We crave more speed, so we integrate more components in one place. Then we desire more flexibility, so we split components apart again. Does any of this thrash help us build better systems, or does it just create full employment for the kinds of people who work on standards committees?

Join Matthew for his perspective on the development of the NVM Express and NVMe over Fabrics standards and a comparison with other storage standards.  The second half of his talk will see what lessons from the past can be applied to persistent memory.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Thursday/Developing_NVM_Express.webm 
189. Insights - solving every problem for good
Paul Wayper

Every system has problems.  Programs gain unwanted vulnerabilities, hardware does not play nicely with software, configurations conflict, and things just slow down.  Part of the job of a sysadmin has been to try to keep up with the bewildering deluge of fixes, performance tweaks, configuration updates and new incompatibilities that we seem to get every day.  Many of us just leave things broken because we didn't know they weren't working, or didn't know there was a fix for that problem.

Until now.

Red Hat has created a framework called Insights which aims to help sysadmins keep on top of fixing things.  It gathers information from a system and then uses rules to test for conditions known to cause problems.  This can be simple, such as checking the version of an installed package, or as complex as the rule writer desires.  Insights provides a powerful system to be able to notify the user of a problem but actually provide a solution that is customised to that system.  Multiple rule sets can be easily combined to get the best of both community and in-house knowledge.

In this talk Paul will present Insights, give an overview of how it works, and demonstrate how the community can get on board with contributing rules.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Thursday/Insights_solving_every_problem_for_good.webm 
190. Let's write a Debugger!
Levente Kurusa

Ever wondered how does the ever-famous gdb tool work? How do breakpoints work? How does single stepping work? All tools that you may use in day-to-day life, but do you actually know how they work? During this talk, we will deepdive into the numerous tools Linux exposes that you can use to check and modify the state of another running process. Of course, most of it wouldn't be possible with just Linux support, so we will also have a brief look at the available hardware support. Think debug registers and special interrupts. By the end of this talk, hopefully you will walk away with a refreshed knowledge of the interesting world of debuggers.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Thursday/Lets_write_a_Debugger.webm 
191. Unions: The way to hack society's operating system
Robert Lechte

Lots of people who make software want to make a better world. 

We're attracted to Linux and open source because we want community solidarity and because we want to build things in the interests of the common good rather than the interests of shareholders or short term profit.

And we all know that in software lies power: More than any other job, software developers have the power to shape the future.

And yet, we're throwing away power because we don't unionise and organise and stand up for our rights at work. Why let our bosses keep all the power? Why squander our ability to be a powerful political voice? Why let our bosses control the technology, make all the decisions, and take all the money the we software workers generate through our long hours of labour? Why do we allow ourselves to work unpaid overtime on projects and force us to sit in horrible open plan offices?

I'll talk about the importance of unionising and organising, and how to build a movement that gives us real power against the bosses and the ruling class, helping us build better software, better communities, and a better future.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Thursday/Unions_The_way_to_hack_societys_operating_system.webm 
192. Friday Welcome
Bruce Crawley

Welcome to the final day of linux.conf.au 2018!
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Friday_Welcome.webm 
193. Keynote: Containers aka crazy user space fun
Jess Frazelle

Like the movie Plan 9 from outer space, this talk will cover containers from user space. What are they? Where did they come from?
How much koolaid is involved in adopting them into your life... Come for the jokes, stay for the interesting technical details.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Housekeeping_and_Keynote_4_Jessie_Frazelle.webm 
194. Let me secure that for you
Kirk Jackson

Writing secure applications is hard, and often vulnerabilities are found after your application has already been released to production.

But what happens if you’re not able to fix the vulnerabilities quickly? If you don’t have the source code? Or if the vulnerable application is “Enterprise Software”, and you aren’t ever going to be able to fix it? Wouldn’t it be great if the someone else could secure your website for you?

In this talk we describe the approach we use to shield customer’s websites when all other avenues have failed, or when urgency requires a fix as soon as possible. This process of virtual patching works well in the real world, and allows people to have comfort that all their known vulnerabilities are fixed and their applications are as secure as can be.

This talk demonstrates the process of virtual patching using a suite of open source tooling that you can go back to your company and use straight away - tools like ModSecurity and node.js. Our approach is different to the typical approach of WAF vendors, and avoids false-positives by only patching exact, known vulnerabilities discovered in a penetration test, and so we avoid the risk of affecting legitimate users.

We will show how ModSecurity works, including patching some OWASP Top 10 vulnerabilities using ModSecurity rules. We will then discuss how to fix more complex business logic flaws by writing javascript code running in node.js. This allows you to rewrite traffic to and from your website, track the state of users, sessions and requests, and fix complex issues that cannot be done using a WAF on it’s own. 

Prior knowledge: This talk assumes understanding of the HTTP protocol, and common OWASP Top 10 vulnerabilities. Some experience reading Javascript would be useful, however the examples presented should be explained in a way that makes sense to non-coders.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Friday/Let_me_secure_that_for_you.webm 
195. Flying autonomous aircraft: Mixed-criticality support in seL4
Gernot Heiser

We have cracked the problem of safely combining real-time tasks of different criticality on a single system image, removing the main show-stopper for complex mixed-criticality systems as they are emerging in cyberphysical systems such as autonomous vehicles.

Mixed-criticality systems (MCS) consolidate multiple functionalities of differing criticality (i.e. severity of failure). MCS are already a reality in avionics, although to date with severe restrictions. A core requirement of MCS is that the correct operation, including timeliness, of critical components must not depend on any less critical components. This requires enforcement of strong spatial and temporal isolation by the OS. Given that MCS are often life-critical, this isolation must be truly bullet-proof, and must be able to stop interference by less critical components that are potentially compromised by an attacker.

The industry-standard approach, e.g. mandated by avionics standard ARIC 653, uses strict time-and-space partitioning (TSP), where each component is sandboxed in a fixed memory partition and executes according to a statically configured schedule. This approach is too limiting for emerging MCS, as it inherently leads to poor resource utilisation and inhibits sharing across criticalities. Such sharing is important; e.g. in an autonomous aircraft, the less critical ground-station communication component must be able to update waypoints used by the highly-critical flight-control component.

The recently released MCS branch of the formally-verified seL4 microkernel is the first OS that truly matches the requirements of MCS. seL4 already provides provable spatial isolation, the MCS branch adds a scheduling model that provides the right temporal isolation. In particular, it provides time budget enforcement, that can prevent high-priority threads from monopolising the processor.

In this talk I will first give a refresher on seL4 and its formal verification story. I will then discuss the requirements of MCS in detail, based on example use cases, and explain why they cannot be matched by existing systems. I will then present the seL4 MCS support and show how it meets the requirements. I will also present autonomous aerial vehicle (AAV) case studies.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Friday/Flying_autonomous_aircraft_Mixedcriticality_support_in_seL4.webm 
196. The RomCom, the App and the Wardrobe
Hannah Thompson

22 years ago, the coming-of-age romantic comedy film Clueless introduced teenage girls (amongst others) to the possibility of using computers and artificial intelligence for fashion. The main character, status obsessed Cher, uses her classic Mac (with added touchscreen) to swipe through her virtual wardrobe and create a real outfit. This movie, a modern remake of a Jane Austen classic, looked into the future with it's wardrobe app - and has become the inspiration for many actual clothes management software projects. For example, in 2017, Amazon released Echo Look - a robot that hides in your wardrobe and judges your clothing.

This talk will discuss the creation of a modern, open source app using open source tools, through the lens of it's Clueless inspiration. Utilising Facebook open source tools React Native and Redux, Jules' Wardrobe is a recreation of Cher's Wardrobe. While Cher and Jane Austen could only have dreamed of holding their wardrobes in their hands, it is now a possibility.

Audience takeaways will include an overview of creating mobile phone applications with open source tools, a better understanding of the potential for using technology with fashion, and an overall sense of nostalgia for 90s movies.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/The_RomCom_the_App_and_the_Wardrobe.webm 
197. Device Tree: Past, Present, and Future
Neil Armstrong

Since the switch of the ARM Linux support from the stable PowerPC Device Tree support, it became an important piece of software used to describe all sorts of devices based on very different hardware architectures.
Currently, BSD* Unixes and even the Zephyr RTOS has switched to Device Tree to describe the hardware. U-boot has also a file format using the Device Tree blob format.
Neil will present you the history of Device Tree from its origins, how it has been used for ARM from the PowerPC codebase, all the very different current usage and an overview of its future application and evolutions.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Friday/Device_Tree_Past_Present_and_Future.webm 
198. Self-Documenting Coders: Writing Workshop for Devs
Heidi Waterhouse

Being able to use language effectively saves so much coding trauma. You should learn to file good bug reports, write up problems, and describe what you're doing. I'll teach you in less than half a day!

What is a documentation structure, and why does it matter to developers? 
Lots of developers get asked to write their own documentation, especially internal documentation and onboarding. In theory, this is good because they know the problems they are writing about and don't need to spend time explaining them. In practice, developers avoid this work because they don't have a good idea of how to start and can't evaluate whether they have succeeded. 

This workshop is designed to teach you a few basic theories of technical documentation, such as task-based topics, reusable content, and writing for an audience. After the overview, you'll learn techniques for writing bug reports, error messages, and onboarding instructions in a tool-agnostic, repeatable way. You'll leave this workshop with a handful of techniques, templates, and tests that will improve your team’s communication and your life as a developer.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Friday/SelfDocumenting_Coders_Writing_Workshop_for_Devs.webm 
199. Elfen Scheduling: Fine-Grain Principled Borrowing from Latency-Critical Workloads using SMT
Xi Yang

Web services from search to games to stock trading impose strict Service Level Objectives (SLOs) on tail latency. Meeting these objectives is challenging because the computational demand of each request is highly variable and load is bursty. Consequently, many servers run at low utilization (10 to 45%); turn off simultaneous multithread- ing (SMT); and execute only a single service — wasting hardware, energy, and money. Although co-running batch jobs with latency critical requests to utilize multiple SMT hardware contexts (lanes) is appealing, unmitigated sharing of core resources induces non-linear effects on tail latency and SLO violations.


We introduce principled borrowing to control SMT hardware execution in which batch threads borrow core resources. A batch thread executes in a reserved batch SMT lane when no latency-critical thread is executing in the partner request lane. We instrument batch threads to quickly detect execution in the request lane, step out of the way, and promptly return the borrowed resources. We introduce the nanonap system call to stop the batch thread’s execution without yielding its lane to the OS scheduler, ensuring that requests have exclusive use of the core’s resources. We evaluate our approach for colocating batch workloads with latency-critical requests using the Apache Lucene search engine. A conservative policy that executes batch threads only when request lane is idle improves utilization between 90% and 25% on one core depending on load, without compromising request SLOs. Our approach is straightforward, robust, and unobtrusive, opening the way to substantially improved resource utilization in datacenters running latency-critical workloads.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Friday/Elfen_Scheduling_FineGrain_Principled_Borrowing_from_LatencyCritical_Workloads_using_SMT.webm 
200. Modernising firmware testing on POWER with Python and pre-release everything
Stewart Smith

Some people have the odd expectation that they will be able to (reliably) turn their computers on and off. On top of that, other people seem to have the entirely unreasonable expectation to have their computers reliably boot an Operating System, perform consistently, and not catch fire. In order to meet these outrageous expectations, we need to test firmware before we release it to an unsuspecting public.

After all, isn't the gold standard of testing "if it boots, ship it" ? In the era of Blockchain, the gold standard no longer applies.

As a firmware maintainer, I want the answer to a simple question: "Will I regret merging this code?". A simple and quick automated test suite is in order! Unfortunately, such things are not always around when you need them.

In order to successfully deliver POWER9 systems (new processor, new operating systems, new machines, new BMC software), we would need a high quality, reliable, fast, easy to use, automated firmware test suite that could not only spot regressions, but find new bugs.

This is a tale of code and organizational transformation and discovery during an incredibly tight and largely immobile release schedule.

We'll cover:
- Components of a modern POWER server and how one might test them (on purpose or by accident)
- Practical use of Python in a mix of modern and legacy environments without going insane
- (ab)using existing testing frameworks for (almost) fun and (hopefully) profit
- How to (not) live with old enterprise distros
- Transforming development, test, and management organizations, into test focused ones.
- How on earth do you design a firmware compliance test before you have a test suite anyway?

This talk is brought to you by:
- A Perl script calling a perl script that parses XML with regex that ran a shell script to construct a python script to shell out to expect.
- Unexpected bugs in the TTY layer
- Soft Lockups
- SOL Disconnected by BMC.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Friday/Modernising_firmware_testing_on_POWER_with_Python_and_prerelease_everything.webm 
201. nftables from a user perspective
Duncan Roe

nftables replaces the popular {ip,ip6,arp,eb}tables Firewall and Router utilities.
For some years its status had been "Under Development", but this changed in early 2017.
This talk explores the ease of transition from iptables, and the advantages and drawbacks of nftables.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Friday/nftables_from_a_user_perspective.webm 
202. Driving Virtual Reality from Linux
Keith Packard

Head-Mounted Displays (HMD) are the most common device for presenting
virtual reality to the user. They project independent images to each
eye to construct a stereo view and track the position and orientation
of the head using both inertial measurement and external beacons.

All of the elements in the system introduce varying amounts of delay
between the motion of the head and the perception of the image by the
user. Computing the projected images thus requires predicting where
the user will be facing when the image is finally emitted from the
display.

As the user is strapped into the HMD and their visual field is limited
to that provided by the HMD, timing errors in the VR presentation can
cause disorientation leading to nausea or other effects. This leads to
strong latency bounds through the entire application pipeline.

A traditional window system, running multiple applications, cannot
easily provide the guarantees needed by a VR system. Competing
applications may consume window system resources and cause jitter in
the VR presentation. Separating the VR application from the window
system can allow it to operate without interference from other
applications and improve performance.

Started at LCA last year in Hobart, the new DRM Leasing mechanism
allows applications to take over a set of display resources from the
window system and drive them directly. These changes involved
modifications to the Linux kernel, X window system and Mesa Vulkan
implementation. This new system brings proposed Vulkan extensions for
direct display operation to the DRM environment.

The presentation will discuss the design and implementation of the
system, along with highlights of the development process and a
live demonstration of the resulting system.

All of this free software was developed under contract with Valve, who
are using it to provide support for the HTC VIVE HMD.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Driving_Virtual_Reality_from_Linux.webm 
203. The State of Kernel Self-Protection
Kees Cook

The Kernel Self-Protection Project focuses on addressing gaps in Linux's defensive technologies. With Linux reaching into every corner of modern life, and userspace frequently being very locked-down, the kernel has become an ever-increasing target for attackers and much more needs to be done to harden the kernel so it can protect itself. A quick overview will be shown of what we're trying to protect Linux against, as well as the state of the art in available technologies. Also presented will be a summary of the last year's participation by many people over a wide range of technologies, with a review of KSPP attempts, accomplishments, active efforts, and an examination of future projects and goals.

Slides: https://outflux.net/slides/2018/lca/kspp.pdf

Video: https://www.youtube.com/watch?v=bFe9R65VnAw
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Friday/The_State_of_Kernel_SelfProtection.webm 
204. Broadcom's Open Source Graphics Stack
Eric Anholt

Two years ago at LCA, Eric presented a new Mesa 3D driver ("vc4") for the Raspberry Pi, full of hope for replacing the closed source graphics software on the platform.  Now, the closed source 3D has been successfully replaced, and the closed source modesetting is on its way out as well.  The first part of the talk will cover the state of the Raspberry Pi graphics situation and what there is left to do.

However, Eric has a new project now: the "vc5" graphics driver for Broadcom's next generation of graphics chips in their set top boxes.  The new driver has learned some lessons from the last few years of development, and builds on the strong cross-driver compiler foundation in Mesa.  He will present initial results of building an open source Mesa OpenGL ES 3.x and Vulkan driver for these new chips.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Broadcoms_Open_Source_Graphics_Stack.webm 
205. QUIC: Replacing TCP for the Web
Jana Iyengar

QUIC is an encrypted, multiplexed, and low-latency transport protocol designed from the ground up to improve transport performance for HTTPS traffic and to enable rapid deployment and continued evolution of transport mechanisms. QUIC has been globally deployed at Google on thousands of servers and is used to serve traffic to a range of clients including a widely-used web browser (Chrome) and a popular mobile video streaming app (YouTube). We estimate that 7% of Internet traffic is now QUIC. QUIC is now maturing from a Google experiment to a more complete Internet standard at the IETF. This talk will provide an overview of the QUIC protocol and the current state of its development and deployment. I will describe motivations for developing a new transport, QUIC's design and the principles that guide it, and performance improvements seen by various Google services due to QUIC. This talk will also share lessons about transport design and the Internet ecosystem that we have learned from QUIC's deployment.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Friday/QUIC_Replacing_TCP_for_the_Web.webm 
206. Making distributed storage easy: usability in Ceph Luminous and beyond
Sage Weil

Distributed storage is complicated, and historically Ceph hasn't spent a lot of time trying to hide that complexity, instead focusing on correctness, features, and flexibility.  There has been a recent shift in focus to simplifying and streamlining the user/operator experience so that the information that is actually important is available without the noise of irrelevant details. Recent feature work has also focused on simplifying configurations that were previously possible but required tedious configuration steps to manage.

This talk will cover the key new efforts in Ceph Luminous that aim to simplify and automate cluster management, as well as the plans for upcoming releases to address longstanding Cephisms that make it "hard" (e.g., choosing PG counts).
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Friday/Making_distributed_storage_easy_usability_in_Ceph_Luminous_and_beyond.webm 
207. A division of labor in free software
Molly de Blanc

We like to think that diversity has increased over time--contributors have stuck around as they age, students are excited to get started, initiatives are making space for people of color, trans* individuals, women, and other groups underrepresented in free software. We like to think we are doing better at recognizing the wide range of contributions and that more people are getting involved from all spheres of skill type, level, and experience.

But is this true? Molly de Blanc, a free software activist with a fondness for numbers and data, analyzed the results from four community surveys from 2003, 2013, 2016, and 2017 (as well as other bits of data around the internet). With fourteen (incomplete) years of community data, she'll attempt to quantify the ways the make up of free software has changed, where we're not doing as well as we'd like, and how we can do better.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Friday/A_division_of_labor_in_free_software.webm 
208. Please Contain Me: Practical LXC on the Desktop
Florian Haas

So you're running a Linux desktop, and it's getting cluttered. There's that weird library you installed ages ago that messes up your package dependencies every upgrade, proprietary software that was last updated for the Ubuntu version you ran three years ago, and then of course you also need a bunch of Python, Go, and Ruby dev environments that all come with their own package managers. Wouldn't it be nice to have a cleaner, saner, more compartmentalised setup?

Enter LXC.

LXC is the underrated wallflower of Linux container runtimes. It's been around for longer than just about everything else, it's stable, it has a decent userland, and it comes with neat features that make it saner and more secure than its contenders — but very few people use it to its full potential.

In this tutorial, I'll show you how to run an arbitrary number of LXC containers on your desktop, all configured with Ansible so that whenever a container starts to look even remotely off, you can just throw it away and start over in minutes. You'll learn how to run unprivileged containers under your own user context, use a shared /home directory across all your containers (and make it work), run containerized X applications that talk to your host X and sound server, and selectively make host resources (such as a webcam, or USB printer) available in your container. I've been using this approach on my own Ubuntu desktop for a couple of years, on a daily basis.

To make the most of this tutorial, please come with a desktop that already has LXC and a current version of Ansible installed.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/largepod/Friday/Please_Contain_Me_Practical_LXC_on_the_Desktop.webm 
209. You Should Speak
E. Dunham

You've been hearing from presenters from all walks of life during this conference, and perhaps it's made you wonder: Could you be one, too? You might have a topic in mind that you'd love to share with others, or you could still be undecided on what to speak about. Either way, I'll demystify the process of writing a talk, submitting it to the right calls for papers, and making sure everyone in the audience leaves the room knowing something new.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Friday/You_Should_Speak.webm 
210. The Web Is Dead! Long Live The Web!
Sam Thorogood

It's time to build for the web, again.

It was declared dead[1], largely in favour of native apps. But the web, the biggest and most open platform we have, is fighting back[2]—it's caught up with features only available in proprietary, native APIs, including making websites feel more 'app-like'. Sure, native development has it's place—but only if you're big, or lucky. For you as a developer, the web provides a frictionless way to reach users (while providing 'app-like features') all via a single href.

For a history lesson: in 2007, smartphones hit the mainstream. Steve Jobs announced the first iPhone. At the time, Apple famously (albeit briefly) resisted "apps", instead directing developers to 'write amazing Web 2.0 and Ajax apps'[3].

Of course, native apps quickly came to dominate, as we now have closed app ecosystems on these billions on mobile devices. This is not without good cause; it's difficult to imagine the next trendy social platform or addictive, casual game appearing as anything but "the latest native app". On the other hand, these ecosystems are dominated by a few behemoths. The average mobile user spends the majority of their time in just a few apps—no prizes for guessing what they are—and installs an average of zero[5] or one[6] new app per month.

But the web has maintained its incredible reach since before the Age of Apps. Sites that deliver content have been able to do it whether the user's browser was automatically updated last night or is an unpatched mess of security holes from several years ago.

Modern, 'evergreen'[4] browsers—like Chrome, Edge, Firefox and Safari—have also helped drive a rapid iteration of APIs on the web. These are the 'triple-A' of browsers, and as developers, we can target them via the best of the best APIs—because we can be confident they're up to-date—while shipping the same or a similar website to old browsers. This all works because, fundamentally, HTML is still the same as it was ten or even twenty years ago.

Today, we can build what's called a "Progressive Web App", or PWA. This describes a site using the group of APIs that let the web act in an 'app-like' way—but more importantly, it's the phrase you tell your manager or your investors who only want "an app"! These APIs include:
* Websites that work and load on a poor or or offline connection
* That can push native notifications to users (where accepted)
* And which can have an icon on a user's home screen, or in any place an 'App' might appear

In this talk, I'll show you how to create a Progressive Web App and demonstrate the APIs that make up this definition, and talk about the future of the standard, open web.

[1]: https://www.wired.com/2010/08/ff_webrip/
[2]: https://www.wired.com/2016/04/wait-web-isnt-really-dead-google-made-sure/
[3]: https://9to5mac.com/2011/10/21/jobs-original-vision-for-the-iphone-no-third-party-native-apps/
[4]: http://eisenbergeffect.bluespire.com/evergreen-browsers/
[5]: https://www.recode.net/2016/9/16/12933780/average-app-downloads-per-month-comscore
[6]: https://www.tune.com/blog/no-the-average-american-does-not-download-0-apps-each-month/
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/collab/Friday/The_Web_Is_Dead_Long_Live_The_Web.webm 
211. Remote Work: My first decade working from the far end of the earth
John Dalton

Even though the open source community is one in which online collaboration is the norm, I still tend to get a lot of questions from people when they first find out that I work completely remotely.
"How did you get a job like this?"
"What's it like to work from home?"
"Oh, I couldn't do that - you must be so disciplined!"
"What tools do you need to be succesful at remote work?"

It's been ten years now since I first took a leap into the unknown and started working remotely for a small company on the other side of the world. I've changed jobs since, and worked with people based all over the globe. This milestone seemed like a great chance to take a step back and look at the bigger picture, and to discuss the practice of remote work with coworkers and colleagues, past and present.

In this talk I'll discuss the challenges and opportunities that remote work brings, what it takes - both personally and organisationally - for remote work to be successful, and what it's like to go a decade without a coworker on the same continent. We'll talk about what kind of software and practices an organisation can use to enable remote work, and most importantly we'll talk about how crucial workplace culture is in allowing remote work to succeed.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/medium/Friday/Remote_Work_My_first_decade_working_from_the_far_end_of_the_earth.webm 
212. Mass Production: Open-source Testing in Manufacturing
Sean Cross

Congratulations on funding your open source hardware project! After the crowd campaign ends, once the design is done, as soon as units start rolling off the factory line, you need to make sure each item is correctly built. To do this, you turn to a factory test jig.

Factory test jigs tend to be highly confidential and proprietary, or else they're considered merely an afterthought, an inconvenient requirement on the road to production.  As such, there isn't a lot of information available on them. Test jigs tend to be bespoke, with little software reuse between products, and almost no software reuse between companies.

This talk will discuss some common pitfalls experienced during manufacturing, common mistakes that are made, and explain just how hostile an environment factories can be to developing software.  We'll share stories from the assembly line, and discuss our open-source factory-friendly testing infrastructure. Come hear talks about the software, plans for the future, and some horror stories that we've encountered in the factory when developing it.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/guthrie/Friday/Mass_Production_Opensource_Testing_in_Manufacturing.webm 
213. The Serial Device Bus
Johan Hovold

In embedded systems, UARTs are a commonly used peripheral interface (e.g. for Bluetooth, NFC, and GPS) even if the kernel infrastructure for dealing with such devices has been both limited in what it can provide (e.g. in terms of power management) and cumbersome to use (e.g. requiring user-space daemons). This presentation will give an introduction to the recently merged Serial Device Bus, which aims to overcome some of these limitations by making UART-attached devices fit better into the Linux device model.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/The_Serial_Device_Bus.webm 
214. Don't Look Back in Anger: Wildman Whitehouse and the Great Failure of 1858
Lilly Ryan

In the 1850s, Edward Orange Wildman Whitehouse was appointed the lead engineer of the first attempt to build a trans-Atlantic telegraph cable. With the entire population of two continents waiting for his go-live, their handlebar moustaches aquiver, he demonstrated in fine form just how spectacularly a big project can be a bigger disaster.

This is a tale of long-winded rants, spectacular sideburns, and gentlemen scientists behaving badly. It is also a lesson about the importance of honest reflection in technical teamwork. Lilly outlines some of the mistakes made during one of the biggest tech delivery projects in history, and how a constructive view of failure helped to turn it all around. Through the public meltdowns of Wildman Whitehouse you will learn the importance of feedback, how to handle complex tasks gracefully, and the best way to recover from having your pipeline eaten by a whale.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/green/Friday/Dont_Look_Back_in_Anger_Wildman_Whitehouse_and_the_Great_Failure_of_1858_2.webm 
215. Lightning talks
Bruce Crawley

A series of lightning talks to finish off the conference. Each talk will be between 3-5mins in length. Signup will be available during the conference week.
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Lightning_talks_6.webm 
216. Conference Closing
Bruce Crawley

The end of linux.conf.au 2018
 recording release: yes license: CC BY  
 Video: http://mirror.linux.org.au/pub/linux.conf.au/2018/greathall/Friday/Conference_Closing_6.webm 


Location
--------
Great Hall CB01.05.009


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/