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 John Hood Plaza Mon January 12, 8:45p
linux.conf.au
=========================
When: 8:45 AM Monday January 12, 2015
Where: John Hood Plaza
http://linux.conf.au
Topics
------
1. Maori Welcome
(Needs description.)
recording release: yes license: CC-BY-SA
2. Main conference opening
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Main_conference_opening_2.webm
3. Open Radio Miniconf
Kim Hawtin
Like open hardware and kits? Would you like to build a Software Defined Radio?
Want to explore how your data is sent over radio? Then this miniconf is for you!
Some assembly required!
By the end of the day, you will:
- Learn how radios work and grok what Software Defined Radio (SDR) is about
- Learn to solder leaded and surface mount components and wind an inductor (or three)
- Build experience in using open radio software
- Learn about the mysteries of software defined radio including (now don’t be frightened) Inphase-Quadrature (IQ) receiver techniques
- Gain experience and understanding in how “digital modes” work over radio; such as amplitude and frequency keying
- Build a general coverage SDR Receiver, tuning shortwave radio bands (3 - 30 MHz), and a simple 100mW ISM band transmitter to take home. Beware, this hardware will be a gateway drug to Ham Radio!
- Understand basic regulations of using low power and unlicensed ISM spectrum
- Send text messages to each other over the air. with your radio hardware and open source software
You provide; a laptop with Linux, a spare USB port, and ideally basic soldering tools. Soldering experience is desirable but not essential.
We provide; a low cost kit - around $50 - with all the help you need to build, test and debug your very own Software Defined Radio (SDR).
For current schedule information see
- https://linux.conf.au/wiki/Open_Radio_Miniconf
recording release: yes license: CC-BY-SA
4. Supporting Debian machines for friends and family
Francois Marier
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Monday/Supporting_Debian_machines_for_friends_and_family.webm
5. Insights from data mining the kernel patchwork
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Monday/Insights_from_data_mining_the_kernel_patchwork.webm
6. Cloud Herding: Delivering Services Across Multiple Environments
John Mark Walker
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Cloud_Herding_Delivering_Services_Across_Multiple_Environments.webm
7. Disentangle a new fangled image mangler
Katie McLaughlin
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/Disentangle_a_new_fangled_image_mangler.webm
8. Introduction
Kate Chapman
(Needs description.)
recording release: yes license: CC-BY-SA
9. Missing Maps Project - Putting the World's Most Vulnerable on the Map: Kate Chapman
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Missing_Maps_Project_Putting_the_Worlds_Most_Vulnerable_on_the_Map_Kate_Chapman.webm
10. Learning to sight read with PHP and LilyPond
Ben Savage
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/Learning_to_sight_read_with_PHP_and_LilyPond.webm
11. Introduction to Humanitarian Response: Chris Daley
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Introduction_to_Humanitarian_Response_Chris_Daley.webm
12. LXD
Tycho Andersen
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/LXD.webm
13. MediaGoblin: The Decentralized Hosting Service for Artists
Deb Nicholson
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/MediaGoblin_The_Decentralized_Hosting_Service_for_Artists.webm
14. Kernel network stack challenges at increasing speeds
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Monday/Kernel_network_stack_challenges_at_increasing_speeds.webm
15. Panel: Getting packages into Debian
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Monday/Panel_Getting_packages_into_Debian.webm
16.
(Needs description.)
recording release: yes license: CC-BY-SA
17. Map My Rights Foundation - Open Source for Land Tenure: Noel Taylor
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Map_My_Rights_Foundation_Open_Source_for_Land_Tenure_Noel_Taylor.webm
18. Rocket and the App Container Spec
Brandon Philips
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Rocket_and_the_App_Container_Spec.webm
19.
(Needs description.)
recording release: yes license: CC-BY-SA
20. Codec 2 at very low bit rates
David Rowe
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/Codec_2_at_very_low_bit_rates.webm
21. Sahana Software Foundation - Crisis Management Software: Michael Howden
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Sahana_Software_Foundation_Crisis_Management_Software_Michael_Howden.webm
22. Open Radio Miniconf
Kim Hawtin
Like open hardware and kits? Would you like to build a Software Defined Radio?
Want to explore how your data is sent over radio? Then this miniconf is for you!
Some assembly required!
By the end of the day, you will:
- Learn how radios work and grok what Software Defined Radio (SDR) is about
- Learn to solder leaded and surface mount components and wind an inductor (or three)
- Build experience in using open radio software
- Learn about the mysteries of software defined radio including (now don’t be frightened) Inphase-Quadrature (IQ) receiver techniques
- Gain experience and understanding in how “digital modes” work over radio; such as amplitude and frequency keying
- Build a general coverage SDR Receiver, tuning shortwave radio bands (3 - 30 MHz), and a simple 100mW ISM band transmitter to take home. Beware, this hardware will be a gateway drug to Ham Radio!
- Understand basic regulations of using low power and unlicensed ISM spectrum
- Send text messages to each other over the air. with your radio hardware and open source software
You provide; a laptop with Linux, a spare USB port, and ideally basic soldering tools. Soldering experience is desirable but not essential.
We provide; a low cost kit - around $50 - with all the help you need to build, test and debug your very own Software Defined Radio (SDR).
For current schedule information see
- https://linux.conf.au/wiki/Open_Radio_Miniconf
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/NICAI_Workshop/Monday/Open_Radio_Miniconf_2.webm
23. Q&A/Speaker Panel
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/QASpeaker_Panel.webm
24. Packaging Samba4 for Debian
Andrew Bartlett
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Monday/Packaging_Samba4_for_Debian.webm
25. State of the GStreamer project
Jan Schmidt
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/State_of_the_GStreamer_project.webm
26. SLUB fastpath improvements and potential booster shots through bulk alloc and free
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Monday/SLUB_fastpath_improvements_and_potential_booster_shots_through_bulk_alloc_and_free.webm
27. AWS OpsWorks Orchestration War Stories
Andrew Boag
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/AWS_OpsWorks_Orchestration_War_Stories.webm
28. Slim Application Containers from Source
Sven Dowideit
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Slim_Application_Containers_from_Source.webm
29. Writing custom Gstreamer plugins for art and science
Douglas Bagnall
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/Writing_custom_Gstreamer_plugins_for_art_and_science.webm
30. Unconference Pt1
(Needs description.)
recording release: yes license: CC-BY-SA
31. Documentation MiniConf Opening
(Needs description.)
recording release: yes license: CC-BY-SA
32. Containers and PCP (Performance Co-Pilot)
Nathan Scott
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Containers_and_PCP_Performance_CoPilot.webm
33. Ten Surprising Lessons I Learned from Launching an Open Source TechComm Startup
David Ryan
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/David_Ryan.webm
34. The Challenges of Containerizing your Datacenter
Daniel Hall
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/The_Challenges_of_Containerizing_your_Datacenter.webm
35. Finding a Great Project to Work On, or Great People to Work on Your Project
Deb Nicholson of Media Goblin
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Finding_a_Great_Project_to_Work_On_or_Great_People_to_Work_on_Your_Project.webm
36. Bootstrapping a new programming language
Angus Lees
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Monday/Bootstrapping_a_new_programming_language.webm
37. Building a PaaS with Docker Kubernetes and Hard Work
Steven Pousty
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Building_a_PaaS_with_Docker_Kubernetes_and_Hard_Work.webm
38. Open Radio Miniconf
Kim Hawtin
Like open hardware and kits? Would you like to build a Software Defined Radio?
Want to explore how your data is sent over radio? Then this miniconf is for you!
Some assembly required!
By the end of the day, you will:
- Learn how radios work and grok what Software Defined Radio (SDR) is about
- Learn to solder leaded and surface mount components and wind an inductor (or three)
- Build experience in using open radio software
- Learn about the mysteries of software defined radio including (now don’t be frightened) Inphase-Quadrature (IQ) receiver techniques
- Gain experience and understanding in how “digital modes” work over radio; such as amplitude and frequency keying
- Build a general coverage SDR Receiver, tuning shortwave radio bands (3 - 30 MHz), and a simple 100mW ISM band transmitter to take home. Beware, this hardware will be a gateway drug to Ham Radio!
- Understand basic regulations of using low power and unlicensed ISM spectrum
- Send text messages to each other over the air. with your radio hardware and open source software
You provide; a laptop with Linux, a spare USB port, and ideally basic soldering tools. Soldering experience is desirable but not essential.
We provide; a low cost kit - around $50 - with all the help you need to build, test and debug your very own Software Defined Radio (SDR).
For current schedule information see
- https://linux.conf.au/wiki/Open_Radio_Miniconf
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/NICAI_Workshop/Monday/Open_Radio_Miniconf_3.webm
39. Unconference Pt2
(Needs description.)
recording release: yes license: CC-BY-SA
40. VLC mobile ports and Mobile Multimedia
Jean-Baptiste Kempf
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/VLC_mobile_ports_and_Mobile_Multimedia.webm
41. Documentation and Community Management.
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Authorea_Open_Source_Tooling_for_Science_Writers_Dr_Maia_Sauren.webm
42. Every Page is Page One: A demonstration involving bears, and Play Doh
Lana Brindley of Rackspace
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Every_Page_is_Page_One_A_demonstration_involving_bears_and_Play_Doh.webm
43. How Synchronous Replication and Linux Containers Mesh Together
Raghavendra Prabhu
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/How_Synchronous_Replication_and_Linux_Containers_Mesh_Together.webm
44. VLC Audio/Video output and pipeline architecture
Rémi Denis-Courmont
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/VLC_AudioVideo_output_and_pipeline_architecture.webm
45. Why so many Open Source Projects Fail at Documentation and How You Can Get it Right
Raghavendra Prabhu
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Why_so_many_Open_Source_Projects_Fail_at_Documentation_and_How_You_Can_Get_it_Right.webm
46. Cloud, Containers, and Orchestration Panel
Katie Miller
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Monday/Cloud_Containers_and_Orchestration_Panel.webm
47. Demo/Jam session and lightning talks
Various
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Monday/DemoJam_session_and_lightning_talks.webm
48. Debian
Andrew Ruthven
Debian was the earliest Linux distrubtions to be open for every developer and user to contribute their work. It continues to be the most significant distributor of Linux that is not a commercial entity (and even then, a number of commercial entities base their distributions on Debian).
Debian remains a key part of the Linux ecosystem, this miniconf will collect together people from across the distros as there are a number of common interests.
recording release: yes license: CC-BY-SA
49. How Volunteer Technical Writing Got Me a Job at the World's Hottest Open Source Startup
Sven Dowideit
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/How_Volunteer_Technical_Writing_Got_Me_a_Job_at_the_Worlds_Hottest_Open_Source_Startup_Getting_paid_to_work_on_TWiki_Foswiki_and_Docker.webm
50. Documentation Swarms and Sprints: How to Bee a Runner: Alexandra Settle
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Documentation_Swarms_and_Sprints_How_to_Bee_a_Runner_Alexandra_Settle.webm
51. Tools for the Documentation Life Cycle - The Open Source Way!
Divya Muntimadugu
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Monday/Tools_for_the_Documentation_Life_Cycle_The_Open_Source_Way.webm
52. Mass automatic roll out of Linux with Windows as a VM guest
Steven Sykes
(Needs description.)
recording release: yes license: CC-BY-SA
53.
(Needs description.)
recording release: yes license: CC-BY-SA
54. Farewell , Zac Dover , Red Hat
(Needs description.)
recording release: yes license: CC-BY-SA
55. Reserved
(Needs description.)
recording release: yes license: CC-BY-SA
56. Reserved
(Needs description.)
recording release: yes license: CC-BY-SA
57. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
58. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
59. Reserved
(Needs description.)
recording release: yes license: CC-BY-SA
60. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
61. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
62. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
63. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
64. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
65. Keynote: Eben Moglen
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Keynote_Eben_Moglen.webm
66. Community Leadership Summit
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Tuesday/Community_Leadership_Summit.webm
67. Welcome and Introduction
Michael Still
(Needs description.)
recording release: yes license: CC-BY-SA
68. Open Hardware Miniconf
Jonathan Oxer
The concept of Free / Open Source Software, already well understood by LCA attendees, is complemented by a rapidly growing community focused around Open Hardware and "maker culture". One of the drivers of the popularity of the Open Hardware community is easy access to cheap devices such as Arduino, which is a microcontroller development board originally intended for classroom use but now a popular building block in all sorts of weird and wonderful hobbyist and professional projects.
Interest in Open Hardware is high among FOSS enthusiasts but there is also a barrier to entry with the perceived difficulty and dangers of dealing with hot soldering irons, unknown components and unfamiliar naming schemes. The Miniconf will use the Arduino microcontroller board as a stepping stone to help ease software developers into dealing with Open Hardware. Topics will cover both software and hardware issues, starting with simpler sessions suitable for Open Hardware beginners and progressing through to more advanced topics.
The day will run in two distinct halves. The first part of the day will be a hands-on assembly session where participants will have the chance to solder together a special hardware project developed for the miniconf. Instructors will be on hand to assist with soldering and the other mysteries of hardware assembly. The second part of the day will be presentations about Open Hardware topics, including information on software to run on the hardware project built earlier in the day.
Please see www.openhardwareconf.org for more info.
recording release: yes license: CC-BY-SA
69. Configuration Management - A love story
Javier Turegano
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Configuration_Management_A_love_story.webm
70. Welcome to the Astronomy Miniconf: Jessica Smith
(Needs description.)
recording release: yes license: CC-BY-SA
71. Beaker's Hardware Inventory System
Nick Coghlan
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Beakers_Hardware_Inventory_System.webm
72. Māori astronomy: Dr. Pauline Harris (TBC)
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Māori_astronomy_Dr_Pauline_Harris_TBC.webm
73. Deploying OpenStack Using Containers by Angus Lees
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Deploying_OpenStack_Using_Containers_by_Angus_Lees.webm
74. Testing the cloud in the cloud
Steve Kowalik
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Testing_the_cloud_in_the_cloud.webm
75. Healthy Operations
Phil Ingram
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Healthy_Operations.webm
76. Developments in PCP (Performance Co-Pilot)
Nathan Scott
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Developments_in_PCP_Performance_CoPilot.webm
77. Visualising the Open Universe: Dr. Nicholas Rattenbury
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Visualising_the_Open_Universe_Dr_Nicholas_Rattenbury.webm
78. The Best Test Data is Random Test Data
Fraser Tweedale
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/The_Best_Test_Data_is_Random_Test_Data.webm
79. Introducing OpenStack Swift
John Dickinson
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Introducing_OpenStack_Swift.webm
80. Security options for container implementations
Jay Coles
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Security_options_for_container_implementations.webm
81. Juju Deployments at Canonical
Brad Marshall
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Juju_Deployments_at_Canonical.webm
82. Developers, sysadmins, and everyone else: Why you should be using Serverspec
Sarah Kowalik & Jesse Reynolds
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Developers_sysadmins_and_everyone_else_Why_you_should_be_using_Serverspec.webm
83. Subunit2SQL: Tracking Individual Test Results in OpenStack's CI System
Matthew Treinish
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Subunit2SQL_Tracking_Individual_Test_Results_in_OpenStacks_CI_System.webm
84. Community Leadership Summit
(Needs description.)
recording release: yes license: CC-BY-SA
85. Open Hardware Miniconf
Jonathan Oxer
The concept of Free / Open Source Software, already well understood by LCA attendees, is complemented by a rapidly growing community focused around Open Hardware and "maker culture". One of the drivers of the popularity of the Open Hardware community is easy access to cheap devices such as Arduino, which is a microcontroller development board originally intended for classroom use but now a popular building block in all sorts of weird and wonderful hobbyist and professional projects.
Interest in Open Hardware is high among FOSS enthusiasts but there is also a barrier to entry with the perceived difficulty and dangers of dealing with hot soldering irons, unknown components and unfamiliar naming schemes. The Miniconf will use the Arduino microcontroller board as a stepping stone to help ease software developers into dealing with Open Hardware. Topics will cover both software and hardware issues, starting with simpler sessions suitable for Open Hardware beginners and progressing through to more advanced topics.
The day will run in two distinct halves. The first part of the day will be a hands-on assembly session where participants will have the chance to solder together a special hardware project developed for the miniconf. Instructors will be on hand to assist with soldering and the other mysteries of hardware assembly. The second part of the day will be presentations about Open Hardware topics, including information on software to run on the hardware project built earlier in the day.
Please see www.openhardwareconf.org for more info.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/NICAI_Workshop/Tuesday/Open_Hardware_Miniconf_2.webm
86. Mass automatic roll out of Linux with Windows as a VM guest
Steven Sykes
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Mass_automatic_roll_out_of_Linux_with_Windows_as_a_VM_guest.webm
87. Open modelling of stars and galaxies from our own to those at the edge of the observable Universe
Dr. J.J. Eldgridge
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Open_modelling_of_stars_and_galaxies_from_our_own_to_those_at_the_edge_of_the_observable_Universe_Dr_JJ_Eldgridge.webm
88. Deploying Nova
Michael Still
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Deploying_Nova.webm
89. Corpus collapsum: Partition tolerance of Galera put to test
Raghavendra Prabhu
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Corpus_collapsum_Partition_tolerance_of_Galera_put_to_test.webm
90. etcd: distributed locking and service discovery
Brandon Philips
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/etcd_distributed_locking_and_service_discovery.webm
91. Introducing OpenStack Neutron
Mark McClain
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Introducing_OpenStack_Neutron.webm
92. Linux at the University
Randy Appleton
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Linux_at_the_University.webm
93. Extending Horizon to work in your Deployment
David Lyle
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Extending_Horizon_to_work_in_your_Deployment.webm
94. The Square Kilometre Array - Hacking the Big Bang: Nicolás Erdödy
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/The_Square_Kilometre_Array_Hacking_the_Big_Bang_Nicolás_Erdödy.webm
95. Kickstart new developers using Docker
Sven Dowideit
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Kickstart_new_developers_using_Docker.webm
96. Untangling the strings: Scaling Puppet with inotify : Steven McDonald
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Untangling_the_strings_Scaling_Puppet_with_inotify_Steven_McDonald.webm
97. Large Scale Identification of Race Conditions (In OpenStack CI)
Joe Gordon
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Large_Scale_Identification_of_Race_Conditions_In_OpenStack_CI.webm
98. Handling RabbitMQ Failures Gracefully with HAProxy
Sachi King
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Handling_RabbitMQ_Failures_Gracefully_with_HAProxy.webm
99. Alerting Husbandry
Julien Goodwin
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Alerting_Husbandry.webm
100. Open Hardware Miniconf
Jonathan Oxer
The concept of Free / Open Source Software, already well understood by LCA attendees, is complemented by a rapidly growing community focused around Open Hardware and "maker culture". One of the drivers of the popularity of the Open Hardware community is easy access to cheap devices such as Arduino, which is a microcontroller development board originally intended for classroom use but now a popular building block in all sorts of weird and wonderful hobbyist and professional projects.
Interest in Open Hardware is high among FOSS enthusiasts but there is also a barrier to entry with the perceived difficulty and dangers of dealing with hot soldering irons, unknown components and unfamiliar naming schemes. The Miniconf will use the Arduino microcontroller board as a stepping stone to help ease software developers into dealing with Open Hardware. Topics will cover both software and hardware issues, starting with simpler sessions suitable for Open Hardware beginners and progressing through to more advanced topics.
The day will run in two distinct halves. The first part of the day will be a hands-on assembly session where participants will have the chance to solder together a special hardware project developed for the miniconf. Instructors will be on hand to assist with soldering and the other mysteries of hardware assembly. The second part of the day will be presentations about Open Hardware topics, including information on software to run on the hardware project built earlier in the day.
Please see www.openhardwareconf.org for more info.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/NICAI_Workshop/Tuesday/Open_Hardware_Miniconf_3.webm
101. Period Analysis of light curves of MoA database: finding periods of variable stars
Man Cheung Alex Li
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Period_Analysis_of_light_curves_of_MoA_database_finding_periods_of_variable_stars_Man_Cheung_Alex_Li.webm
102. Selling Mist: Better Metering Through Ceilometer
Sharif Olorin
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/Selling_Mist_Better_Metering_Through_Ceilometer.webm
103. Gerrit & Gertty: A Daily Habit
Anita Kuno
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Gerrit_Gertty_A_Daily_Habit.webm
104. Community Leadership Summit
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Tuesday/Community_Leadership_Summit_3.webm
105. Managing microservices effectively
Daniel Hall
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Managing_microservices_effectively.webm
106. Incorporating the Security Development Life Cycle and Static Code Analysis
Dr. Jason Cohen
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Tuesday/Incorporating_the_Security_Development_Life_Cycle_and_Static_Code_Analysis_into_our_Everyday_Development_Lives_An_Overview_of_Theory_an.webm
107. Data Mining the MOA Catalogue Using Machine-Learning Algorithms: Martin Donachie
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Data_Mining_the_MOA_Catalogue_Using_MachineLearning_Algorithms_Martin_Donachie.webm
108. Corralling logs with ELK
Mark Walkom
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Corralling_logs_with_ELK.webm
109. GPU-accelerated Modeling of Microlensing Events: Ashna Sharan
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/GPUaccelerated_Modeling_of_Microlensing_Events_Ashna_Sharan.webm
110. Discussion / Q&A
(Needs description.)
recording release: yes license: CC-BY-SA
111. OpenStack Operations for Engineers
Alex Tesch; Daniel Martushev; and Anthony Rees
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Tuesday/OpenStack_Operations_for_Engineers.webm
112. FAI -- the universal deployment tool
Thomas Lange
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/FAI_the_universal_deployment_tool.webm
113. Documentation made complicated
Eric Burgueno
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Tuesday/Documentation_made_complicated.webm
114. Lightning talks: Brief presentations from miniconf attendees
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Tuesday/Lightning_talks_Brief_presentations_from_miniconf_attendees.webm
115. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
116. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
117. Reserved
(Needs description.)
recording release: yes license: CC-BY-SA
118. Reserved
(Needs description.)
recording release: yes license: CC-BY-SA
119. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
120.
(Needs description.)
recording release: yes license: CC-BY-SA
121. Speaker Dinner Bus
(Needs description.)
recording release: yes license: CC-BY-SA
122. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
123. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
124. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
125. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
126. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
127. BoF
(Needs description.)
recording release: yes license: CC-BY-SA
128. Keynote: Bob Young
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/Keynote_Bob_Young.webm
129. Putting the Polish on Glamor
Keith Packard
Glamor, a 2D acceleration subsystem for the X window system, was
started by Eric Anholt in 2008. In the intervening six years, GL
support on common Linux desktop hardware has grown dramatically. This
has allowed us to re-engineer Glamor from the ground up. Glamor now
relies on versions of GL and GLES that permit it to fully accelerate
the X graphics API, essentially eliminating the need for efficient
software fallbacks.
Glamor development has been accelerated by the integration of Glamor
support into the Xepher X-on-X system. This brings the ability to work
on X acceleration to developers with only a single machine capable of
running X, eliminates the need to run development code as root, and
offers faster edit/compile/debug cycles and better debugging tools.
This presentation will describe both the current Glamor architecture,
Xephyr integration, how Glamor uses various GL and GLES versions and
plans for future Glamor work.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/Putting_the_Polish_on_Glamor.webm
130. CoreOS: an introduction
Brandon Philips
The architectural patterns of a large scale platform are changing.
Dedicated VMs and configuration management tools are being replaced by containerization and new service management technologies like systemd.
This presentation will be giving an overview of their key technologies, including etcd, fleet, and docker. Come and learn how to use these new technologies to build performant, reliable, large
distributed systems.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Wednesday/CoreOS_an_introduction.webm
131. Evaluating Government Policies Using Open Source Models
Audrey Lobo-Pulo
“Bernard: But surely the citizens of a democracy have a right to know.
Sir Humphrey Appleby: No. They have a right to be ignorant. Knowledge only means complicity in guilt; ignorance has a certain dignity.”
- From “Yes Minister” written by Antony Jay and Jonathan Lynn
We’ve come a long way with engaging citizens on government policy – the Australian Government’s declaration of open government and the community’s overwhelming interest in open data has paved the way for public debate on a whole new level. Enter the next phase of open government waiting to be unlocked – “Open Source Models”.
Government “open source models” refer to the idea that government developed models whose purpose is to design and evaluate policy, should be freely available to everyone to use and distribute without restrictions. These models may read in either open or closed data and would often consist of two main components – legislation implemented as code and user-defined economic parameters. The output would provide a quantitative measure of the effects of the policies modelled. Some interesting examples might be quantifying the changes in the labour force with increasing migration levels or changes in revenue by altering certain social security payments.
This presentation will put forward the radical idea that government open source models have the potential to play a pivotal role in informing public debate by opening the doors of policy evaluation to the community. Many other interesting issues such as whether these models are a public good, who has ‘ownership’ of taxpayer funded models, how security issues and privacy concerns may be dealt with and what’s the best licensing option for citizen collaboration will also be discussed.
Government open source models promise a future of greater involvement of the open source community in policy development and evaluation. The open source community would have more opportunities for innovation in designing or improving policy and therefore have a greater influence in public debate. An increased transparency through the provision of these models would also promote better accountability of our politicians and the media.
Disclaimer: The views presented belong to Audrey Lobo-Pulo and are not necessarily those of the Australian Government.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Wednesday/Evaluating_Government_Policies_Using_Open_Source_Models.webm
132. Making code run fast on all the things (with OpenCL)
Beau Johnston
Modern computer systems are becoming more heterogenous. This can be seen with
the increased use of accelerator devices and co-processors for both industrial
and personal use. Devices such as Graphical Processing Units (GPUs) offer
improved performance (both in taking a shorter duration to compute and
energy efficiency) for a range of applications. Other tasks are better suited
to the Digital Signal Processor (DSP), Field Programmable Gate Array (FPGA),
another Central Processor Unit (CPU) or any alternative co-processor. All of
these devices are significantly different in architecture and programming
language support. Developing an application for all of these devices results in
much redundancy, fragmentation and frustration by requiring the developer to
write potentially several alternative implementations. This fragmentation can
be really bad for programmers and the Open Source community in general as each
vendor provides their own API's, proprietary tools and restrict our freedoms by
locking us into a third party ecosystem.
Thankfully a language and Open Source standard exists to save us from vendor
hell, the answer is Open Computing Language (OpenCL)!
During this talk I will discuss how to leverage this hardware agnostic language
(from a programmers perspective) and recap on some tips on how to write flexible
kernels once and have them run efficiently on all platforms. Additionally I'll focus on proper utilisation of time... our time (as developers) and the clients. Too often do we put off learning a new language or standard because of the initial time we need to sink into it before we have working code. I'll do this work for you, namely by comparing a few different language implementations of OpenCL with a major emphasis being placed on development time and comparing it against execution time (and what cost does it have your sanity). You'll also be given some running OpenCL boilerplate code in each of these languages, so you can hit the ground running!
Please attend my talk, as I need your help in increasing it's adoption which
will in turn increase vendor support for the lastest, greatest and more
flexible versions of the OpenCL standard.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Wednesday/Making_code_run_fast_on_all_the_things_with_OpenCL.webm
133. The Imperfect Penguin
Marco Ostini
FOSS is one of the most important and rewarding things to happen in our lifetimes, but as we all know it's far from perfect.
Information security problems, despite "many eyeballs" are not uncommon in FOSS projects and some like Heartbleed are so serious that they can only come about after multiple forms of failure.
This talk will overview a broad range of FOSS projects from 'Internet of Things' devices through to infrastructure private clouds depend on, highlighting vulnerabilities, some serious incidents, and how they may have been avoided, or at least handled better.
Lets be honest, doing security right is not easy. This presentation will also take a few steps back and view the larger problems of faulty design, patch fragmentation across platforms and what it means for the average well meaning person.
It's not all doom and gloom however. FOSS has what it takes to overcome these problems; vibrant communities, patch management tools, code signing, swift responses, setting clear expectations and the wisdom of its elders all make it better placed than closed methodologies to get security right.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Wednesday/The_Imperfect_Penguin.webm
134. Bashing the Shell: Advanced Scripting
Martin Kealey
You may know Bash as the command-line interpreter for most Linux users, but it is also the default shell script interpreter in many Linux distributions.
This tutorial would suit people who:
* have fallen into being a sysadmin and need to understand what they've gotten their hands on;
* have been using the command-line for a while and have started writing small scripts to automate some of your tasks, but have often encountered strange or puzzling behaviour;
* have tried looking at the scripts in /etc/init.d, and been found gibbering under the bed hours later;
* want to understand the differences between classic Bourne shell, POSIX shell, Bash, Dash and Ksh;
* have used other programming languages but have found the Shell too arcane.
To gain the most benefit from this tutorial, it would be helpful to have either some programming experience, or at least a year of reasonably extensive use of the command-line.
Included:
* a brief history of Shells
* process & environment management
* common pitfalls and techniques to avoid them
* guidance on "best practice"
* special features for interactive use
* when to give up and use something else
Bring your problems, curiosity, and curly questions, for a hands-on session with worked examples.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Wednesday/Bashing_the_Shell_Advanced_Scripting.webm
135. Software Patents: Trolls and Other Bullies
Deb Nicholson
Lots of small and medium free software projects are staffed by volunteers that don't have any money to tempt a patent aggression entity. There's been plenty of talk about patent trolls, but money isn't the only motive for a patent suit. Even if non-practicing entities are eventually curtailed, ill-intentioned practicing entities may not be affected. The free software community will still have to worry about anti-competitive suits, nuisance suits and suits designed to spread fear, uncertainty and doubt about the adoption of free software. So, what can we as free software builders, promoters and users do to protect the code we care about?
Some solutions are only effective against non-practicing entities, while others may impact all kinds of bad actors. The strengths and weaknesses of proposed legislation, recent and ongoing campaigns and academic writings will be examined. If legislators and international trade negotiators won't take a stand against anti-competitive patent aggression, then we must do so as a community. Find out about some of the community solutions that are underway and how we can combat the threat of anti-FLOSS plaintiffs together.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Wednesday/Software_Patents_Trolls_and_Other_Bullies.webm
136. Why you should consider using btrfs ... like Google does.
Marc MERLIN
Btrfs has seen steady development over time, and is arguably the most modern filesystem available in the linux kernel. Now is time for more users to learn about it and consider using it for multiple kinds of workloads and hopefully help with its development.
The presentation will give you everything you know to get up to speed with btfrs, why you should want to trust your data to btrfs, how it offers a lot of what ZFS offers without the licensing problems, as well as best practices for using it.
I will go into:
- the basics of administration of a btrfs filesystem
- How btrfs, swraid, dmcrypt, and lvm fit or don't fit together
- how to work with a single storage pool and create all your partitions from it without having to ever resize them, or require LVM as a slow and somewhat unreliable block layer.
- how to have virtually as many snapshots as you want and why you really want this
- how to do very efficient block level backups of changes only and much faster than rsync ever will
- how those block backups can be used to deploy OS upgrades at the file level like I explained in my talk on how Google maintains its many servers last year.
I'll also share the simple code I wrote based around btrfs to offer netapp style snapshots as well as easy incremental block diff backups.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Wednesday/Why_you_should_consider_using_btrfs_real_COW_snapshots_and_file_level_incremental_server_OS_upgrades_like_Google_does.webm
137. The kernel report
Jonathan Corbet
The Linux kernel is one of the largest and fastest-moving software development projects on the planet. This talk will cover recent developments in this core operating system component and take a look at what can be expected in the near future. Whether you are a Linux user, application developer, or kernel hacker, you should find something of interest in this talk.
The kernel report has been presented worldwide for years, but this will be its first appearance since late 2013.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/The_kernel_report.webm
138. auprefs.info - A vain attempt to rescue Australian democracy with a JavaScript
Paul Foxworthy
“Graphs are like tiny dollops of science you can hold in your hand”
- First Dog on the Moon
"Above the line" voting in the Australian Senate and State upper houses means your favourite political party can choose where preferences will be distributed, and you may not know, or like, their decisions. In 2012, Paul Foxworthy noticed that even the “how to vote” tickets for his local Council election had a long list of single-issue candidates sending second preferences to the “real” candidate.
With some analysis, you could detect clusters of candidates that seem to be co-operating. But who has the time and patience? Paul looked for, and eventually found, a way to visualise preference data.
auprefs.info is a web site and open source web application to visualise preference distribution in Australian elections. It aims to better inform voters where their vote might go. Knowledge is power - if we can see what our vote is doing, we might be more careful how we exercise it.
Paul will talk about why he did it, and how you can create force-directed graphs and other interactive visualisations using the amazing d3 graphing library.
The source code for the http://auprefs.info site is available under the Apache Licence, version 2.0 at https://bitbucket.org/ConcreteGannet/auprefs.info
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Wednesday/auprefsinfo_A_vain_attempt_to_rescue_Australian_democracy_with_a_little_JavaScript.webm
139. seL4 Is Free – What Does This Mean For You?
Gernot Heiser
seL4 is the world's most secure OS kernel, in a very strong sense: It has a mathematical proof of security that connects high-level security and safety properties with the binary code that is running on the processor, there is no other system that can make such clams. And it is 100% Australian-made.
seL4 runs on ARM and x86 processors and combines the properties of a general-purpose microkernel, a military-style separation kernel, a hypervisor able to run Linux, a protected-mode real-time OS and more. However, until recently it was locked up and basically inaccessible. But, as of 29 July 2014 it is open source.
In this talk I will briefly explain what seL4 is (and isn't), what it can do and where it can be deployed, and what its formal verification is all about, i.e. what it can and cannot guarantee.
Then I will focus on discussing what this means for the community. As seL4 defines the state of the art in trustworthy systems, I will make the point that it is the right platform for new designs of safety- or security-critical systems, where failure can lead to loss of life or may have massive financial impact. I will encourage the community to contribute to building the seL4 ecosystem, and use it to make everyday computer systems more dependable.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Wednesday/seL4_Is_Free_What_Does_This_Mean_For_You.webm
140. The Free Ride: How to Road-Test Automotive Linux on Your Own
Nathan Willis
Car enthusiasts and shade-tree mechanics have been modding their vehicles since almost day one, and the increasing importance of Linux and open-source software shows no sign of slowing them down. In this presentation, Nathan Willis will review his recent personal experience building a homemade Linux-powered in-vehicle infotainment (IVI) system in his personal vehicle, and discuss where the software projects employed succeed and come up short. The topics covered will include power and runtime management, package management and integration, hardware support difficulties, and licensing concerns. Attendees will get practical advice on automotive system building, pointers on how to get involved in open-source automotive projects, and food for thought about software freedom on the highway.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Wednesday/The_Free_Ride_How_to_RoadTest_Automotive_Linux_on_Your_Own.webm
141. What Should a Systems Administration Student's Homework Look Like?
Tom Clark
When we teach computer programming, we have a pretty good idea of what the homework looks like. We have the students write programs, and then we assess the programs' functionality and quality. But what about systems administration? We could have students configure servers and then assess the configuration, but the real work of systems administration is in operating the servers. How do we evaluate that?
In the systems administration course at Otago Polytechnic in Dunedin, New Zealand, students operate a web service using around the clock for two weeks while they are presented with a variety of scenarios and challenges. They are assessed on observed system uptime together with their performance on the problem scenarios. Open source software like Linux, Puppet, and Nagios are used by students and instructors to accomplish this.
In this presentation we will look at lessons learned from running this activity in a recent instance of the course. We will see how the same open source tools used by systems administrators can be used to teach systems administration. We will also discuss work to improve the the delivery and assessment of the activity in the future.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Wednesday/What_Should_a_Systems_Administration_Students_Homework_Look_Like.webm
142. PostgreSQL Replication Tutorial
Josh Berkus
Learn to setup and maintain PostgreSQL built-in replication in this hands-on, bring-your-own-laptop tutorial.
PostgreSQL’s built-in replication is conceptually simple, but the devil is in the details, and this tutorial is all about the details. We will cover the core essentials of how to set up and configure binary replication, using hands-on exercises for some elements, including:
* setup & configuration
* replication security
* cascading replication
* synchronous replication
* failover and failback
* replication mangement tools
Materials and Docker test environments will be available two weeks before the conference; see the wiki page: https://linux.conf.au/wiki/pgReplicationTutorial Attendees are strongly encouraged to download it and set up the learning environment before the tutorial; time will not be given during the tutorial to do so.
Attendees will leave knowing how to set up a simple replication cluster, and about the options for more complex configurations.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Wednesday/PostgreSQL_Replication_Tutorial.webm
143. Coccinelle: A program matching and transformation tool
Himangi Saraogi
Coccinelle is a program matching and transformation engine. It provides the Semantic Patch Language for specifying desired matches and transformations in C code. Coccinelle has been used in the past for finding bugs in Linux and performing collateral evolutions. Coccinelle scripts are part of the Linux source distribution and are being used by Linux developers on a regular basis.
In the presentation, Himangi will review the impact of Coccinelle on the Linux kernel. Himangi will briefly introduce the structure of Coccinelle scripts. She will talk about managed interfaces like devm_ functions. Using example code changes, she will explain how coccinelle helps in detecting and transforming cases for possible use of the managed interfaces in place of the unmanaged interfaces. Himangi will discuss about coccinelle patches such as ARRAY_SIZE, BUG_ON, missing iounmap(which leads to memory leaks) etc.
She will elaborate the various uses of Coccinelle like searching for all functions that have a specific return type or probe function definitions of a driver, renaming a function, adding a function argument whose value is somehow context-dependent, and reorganizing a data structure. Himangi will also highlight the capabilities of coccinelle and the limitations of the tool.
The audience is anyone who are involved in Linux development. Coccinelle, though a very powerful tool is fairly new and is known to limited people in the community. Developers who look at Coccinelle patches initially find it new, feel it is very confusing and when unaware of its capabilities may decide to avoid it.
This presentation will give an overview of how coccinelle can be a very useful tool and will give developers as well as maintainers an opportunity to consider using coccinelle after being exposed to its capabilities and limitations. The maintainers may also suggest using coccinelle or add TODOs if they find a use-case that is well suited to be solved by Coccinelle.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Wednesday/Coccinelle_A_program_matching_and_transformation_tool.webm
144. EQNZ - crisis response, open source style.
Brenda Wallace
On 22 February 2011, a M6.3 eathquake struck Christchurch. For those NZers further from Christchurch, the distant shock and fear for loved ones turned quickly into "What can we do?"
What unfolded was volunteers writing code, reading reports, collating data, researching, confirming information, communicating, fixing critical systems under sudden load with infrastructure broken around it. Our adhoc group used technology we could get instantly: Open Source.
We adapted an existing code base from Boxing day tsunami response to our needs quickly - - and as hours turned into days and weeks and months, our response changed with the changing requests from people in Christchurch.
I will cover the projects we used - the platforms we used to commuicate - the arrangements made to get people into the work quickly, and how we got things done when the modern tech systems we take for granted were not available.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/EQNZ_crisis_response_open_source_style.webm
145. KVM on IBM POWER8 servers
Paul Mackerras
Last June, IBM released server machines based on its new POWER8 processor chip. Among the many cool new features in these systems, one stands out: you can now order these systems with KVM as the hypervisor, as an alternative to IBM's proprietary PowerVM.
Our flavour of KVM (we call it PowerKVM) is based on the Linux kernel, KVM, qemu and libvirt, all of which are open source. We also include the open-source Kimchi web interface for virtualization management, or OpenStack or oVirt can be used for management.
The host kernel on these POWER8 machines uses the services of a piece of firmware called OPAL, for Open Power Abstraction Layer. OPAL is open source, and provides services such as console, real-time clock, non-volatile RAM and a boot loader.
This presentation examines this software stack and covers the issues in porting KVM to run on the POWER8 CPU, which was designed for PowerVM. Some ingenuity was required to bridge the gap to the KVM model of virtualization. In particular, each POWER8 core has 8 hardware threads, but will only run 4 separate guests simultaneously, which creates interesting problems in scheduling guests.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Wednesday/KVM_on_IBM_POWER8_servers.webm
146. collectd in dynamic environments
Florian Forster
Over the last years, the number of services running "in the cloud", on a dynamic pool of virtual machines, has increased dramatically. While "moving to the cloud" poses an opportunity to cut costs and offers new possibilities with regard to scalability, it also creates new problems for system administrators. Many existing open-source monitoring solutions require a centrally configured list of hosts, for example, which is not possible to specify in a cloud environment. Configuring checks for individual hosts also makes less sense than it used to, and the focus is shifted to detecting a misbehaving site instead of fixing a single host.
collectd is a lightweight daemon which collects, processes and stores system and application performance metrics. It comes with over one hundred plugins for all sorts of systems, applications and devices. The daemon is very light-weight and is in wide-spread use in small devices (e.g. OpenWrt) as well as huge, ever changing cloud setups.
This talk will focus on the "cloud" end of the spectrum. First, it will discuss what makes collectd a good choice for performance data collection in such a dynamic environment. It will discuss querying guest metrics from the hypervisor, to collect some basic information about virtual machines without instrumenting them. We will then look at different ways to set up networking using collectd's "network" plugin. We'll discuss per-site and global data aggregation using collectd's "aggregation" plugin and, alternatively, by using Riemann. At last the talk will cover some common storage systems, from the old-but-proven RRDtool to the newer alternatives, such as Graphite.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Wednesday/collectd_in_dynamic_environments.webm
147. REST APIs and the Return of the Console App
James Blair
Text-based interfaces are great for working with, well, text! We talk
to each other in text-based IRC clients. We run compilers and the
programs we write from text-based terminals. We write code in
text-based editors. Some of us even read our email there too. But
increasingly, developer tools are showing up on the web.
A recent trend for web applications to have fully separate REST-based
"backend" systems that are in turn used by "frontend" Javascript
applications has not only freed Javascript developers to write more
expressive applications, but has the unexpected side benefit of
freeing users to create their own preferred interface to tools they
commonly use.
In this presentation, the author will introduce Gertty, a new
console-based interface for the (web-based) Gerrit code review system
and use it to demonstrate the advantages of applications developed
with fully-featured REST interfaces. We will talk about the
challenges of developing a "secondary" interface, the unique
environment of a console app, and the surprising benefits of not being
tied to the web.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Wednesday/REST_APIs_and_the_Return_of_the_Console_App.webm
148. Displayport MST: why do my laptop dockoutputs not work?
David Airlie
Displayport is a VESA standard for transporting video/audio/other data between devices, it is used on lots of laptop and monitors. The Displayport 1.2 standard introduced a new technology called multi-stream transport (MST), and a number of laptop dock manufacturers (Lenovo, Dell) started using this technology to provide the output ports on the dock. However nobody told the Linux community this was coming or at least nobody in the community noticed in time!
So armed with a dock and shiny Lenovo laptop provided by the Red Hat IT department, David descended into the murky world of MST. This talk is his tale. From the laptop docks with Intel graphics, he migrated to the world of 32" monitors with MST requirements and hubs. He diverged into looking at ATI support, and nagged nouveau team members into looking at nvidia support.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/Displayport_MST_why_do_my_laptop_dockoutputs_not_work.webm
149. Checking Your Privilege: A How-To for Hard Things
Leslie Hawthorn
Over the past 3 years, we’ve witnessed the discussion of the role of women and other underrepresented groups in technology grow broader, deeper and louder. From Wired to the Wall Street Journal, we’ve heard the message that we all have a problem. Even more exciting, major tech employers are just starting to respond with hard demographic data to back up years of academic research – and lived experiences – on the gender gap.
So, the first step is admitting we have a problem. But where do we all go from here?
The answer is simple, but the solutions are not: understanding one’s privilege requires hard work. Doing something productive with that understanding is even more difficult. We’ll all require a great deal more empathy for individuals whose lives we’ve never led, whose experiences we’ve never shared and whose challenges are all the same, but still quite different – and often greater – than our own.
In this talk, I’ll provide the audience with a how-to for journeying on the path to greater self-awareness and empathy:
* Understanding your own biases
* Taking the first steps toward leveling up in your interactions
* Having more useful conversations and collaborations with everyone you know
The purpose of this talk is to reexamine the topic through the lens of concrete things individuals can do to check their privilege – and to put it to work serving themselves and others.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Wednesday/Checking_Your_Privilege_A_HowTo_for_Hard_Things.webm
150. The Daala Video Codec Project
Timothy Terriberry
With the recent completion of the next-generation video codecs VP9 and HEVC, Xiph has turned our attention to the "next-next generation". The Daala project aims to design a royalty-free codec that surpasses the performance of the best patent-encumbered formats.
Unlike the rest of the industry, we are not trying to achieve superior performance through dozens of minor optimizations of the same basic coding tools in use since the 1980's. Rather, we are trying some fundamentally different ideas. Some of these are based on old research directions that were never adequately explored. Some of these are new ideas inspired by our prior codec work. This strategy is riskier than making many small, incremental changes, but it offers us a chance to break out of the local minima of current codec design and helps avoid the dense patent thickets built up around the traditional approaches.
This talk will explain how Daala is different, why we think it will work, and how far we've come so far. It is intended for an audience with a technical background who does not already have significant signal processing experience.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Wednesday/The_Daala_Video_Codec_Project.webm
151. Before All Else, Be Graphed
Katie McLaughlin
When working with system metrics, you want to be able to compare different sets of time-series data in order to find patterns and correlations. It is often difficult to compare and contrast information across multiple different datastores.
This is the problem solved by Machiavelli, a web-based visualisation application. Given information about where data lives and how to access it, Machiavelli can show visualisations in a variety of formats, comparing one or more metrics across multiple different data stores, coalesced by time.
The presentation will cover the inspirations and use cases for Machiavelli, including a short demonstration of its use in production, and how it can be extended to show and correlate data from a new datastore.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Wednesday/Before_All_Else_Be_Graphed.webm
152. Using FOI to get source code: the EasyCount experience
Michael Cordover
Most modern discussions about open government focus on "Gov 2.0" initiatives like open data licensing, release of data in machine readable formats and enabling online access to government. However, these mostly rely on pro-active governments providing that access voluntarily.
This opening up of government information is in part due to the excellent work done in the 1990s and 2000s pushing for the adoption of open data standards. This has enabled a greater adoption of open source software by governments.
What we don't see is much government contribution back to open source projects. With only a few exceptions, most software developed for and by government remains closed source. In fact, these projects are often shrouded in secrecy.
The origins of open government policy can be traced to the passage of Freedom of Information (FOI) acts in the 1980s. These provide individuals with a statutory right of access to information produced by government. The basic idea behind FOI was that people should be able to see what their taxpayer dollars were funding.
So, can FOI be used to open up source code for these secretive projects? Perhaps - but not fully, and certainly not easily.
The software used in Australia’s notoriously complicated Senate elections was developed in-house at the Australian Electoral Commission (AEC) and is called EasyCount. In October 2013 I submitted a FOI request asking for the source code for EasyCount and associated documentation. Access was refused on the basis that the code was a trade secret.
The AEC has fought hard to prevent the source code being seen by the public, or even scrutineers from political parties. They even refused to provide me with a list of documents identified.
I’m currently appealing the AEC’s decision through the courts, thanks to more than $10,000 in crowd funding. In return the AEC has sought to have me declared a vexatious applicant. In the middle of it all the Senate passed a motion ordering the responsible minister to table the source code in Parliament, but the government refused to comply.
Even if I win in court (which is far from certain), the code will still be protected by copyright. While the code might be available for inspection, none of the 260,000 lines of code will able to be reused for anything else.
There’s a strong argument that major public investments in software development should result in code released under an open licence. I think FOI can be part of this process, but that we're only seeing the beginning of some major developments in open government policy. Ultimately I hope this will culminate in more government-created software released as open source.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Wednesday/Using_FOI_to_get_source_code_the_EasyCount_experience.webm
153. Hop, Skip, Jump: Implementing a concurrent interpreter with Promises
Timothy Jones
Grace is a relatively new programming language, developed to provide more options for educators introducing programming to students. We have built a non-blocking interpreter for Grace in JavaScript, using a Promise-like API to control asynchronous behaviour. The result is Hopper, an interpreter which can be used as a Node.js command-line tool or as a regular JavaScript library on either Node or the browser. The interpreter uses various techniques to avoid hanging the browser while it is executing, as well as preventing the stack from overflowing during task execution.
This talk will discuss the challenges posed by implementing Hopper. It will investigate the Promises/A+ specification and how our implementation cannot be fully compatible with the spec while providing all of the necessary functionality, and our various attempts at developing our own extensions on top of a compliant system. In particular, we will look at the combination of language features from Grace that require these various extensions, including synchronous APIs, exceptions, and ensuring that 'finally' blocks execute at the appropriate time, as well as demonstrating how easy it is to build concurrent methods for Grace in Hopper. It will also cover the layout of the interpreter and the issue of attempting to support both Node.js and browsers with the same codebase (even in the presence of the browserify tool). Finally, it will consider the challenge of achieving performance in such a setting, where constantly jumping out of execution and deferring to the event loop compounds the more general issue of optimising an interpreter for a dynamic language.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Wednesday/Hop_Skip_Jump_Implementing_a_concurrent_interpreter_with_Promises.webm
154. Towards One MILLION SQL Queries Per Second
Stewart Smith
Over the past 10+ years, MySQL has been dragged kicking and screaming
into the multi-core world and is still the most widely used open source
database.
Ten years ago, MySQL AB's own benchark whitepapers were boasting of
HUNDREDS of transactions per second.
In 2001, what would become MySQL Cluster, on a 72 CPU system, could get
1 million reads per second using the NoSQL C++ NDBAPI.
In 2013, the current stable release (MySQL 5.6) could get 350,000
queries per second on a 32 core system with the current development
release (MySQL 5.7) reaching an astounding 500,000 SQL queries/sec.
Joining IBM at the start of 2014 it was only a matter of time before
someone found out about my (not so) secret life of 10 years knee deep in
MySQL internals.
This is the tale of scaling MySQL throughout the years and scaling MySQL
on the new POWER8 processor.
- Whare are global mutexes and what can you do about them?
- Do atomic variables solve all of your problems?
- How do you deal with NUMA?
- What tools exist to find bottlenecks and find out why you can't get any
more performance out of a system with 42% idle CPU?
- and can you *really* get to 1 million SQL queries per second on a dual socket system?
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/Towards_One_MILLION_SQL_Queries_Per_Second.webm
155. OpenStack and Shenanigans - A Case Study in Open Source Governance
Mark McLoughlin
In its four years of existance, OpenStack has grown at an incredible rate into one of the largest open-source projects on the planet. As with any software project - open-source or not - what's ultimately important is the software we produce but yet we must invest much
effort into perfecting how we produce it. For a project to scale dozens of contributors to thousands of contributors, that's especially true.
This talk with cover the full gamut of OpenStack's governance model - from code reviewing, to CI systems, to release processes, to per-project fiefdoms, to consensus and voting, to overarching beaucracies. Particular attention will be paid to a particularly unusual aspect of OpenStack governance - how the project maintains a balance between commercial interests sponsoring the vast majority of the work done on the project, and the open, transparent and welcoming 'doacracy' which creates the ideal environment for technical collaboration.
This past year has seen a number of fascinating debates within OpenStack - around commercial trademark usage policies, our contributor license agreements, voting methods, cross-project governence, the increase in scope of project, and much more. In this talk, Mark will share his perspective on these debates from his vantage point as a contributor, technical committee member and director of the foundation.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Wednesday/OpenStack_and_Shenanigans_A_Case_Study_in_Open_Source_Governance.webm
156. FPGA killed the video capture star
Joel Stanley
Recording video for streaming and storage is hard.
Open hardware is fun.
Lets create some open hardware to record video!
The timvideos project is an effort to create an easy to use, modern video recording workflow for conferences like linux.conf.au. Central to this effort is HDM2USB, a FPGA based HDMI capture board.
The FPGA system captures video, does compression, USB streaming, and more, and it’s built on open hardware to boot. Come learn about the challenges of designing an open video capture system, and how to use open source to help you along the way.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Wednesday/FPGA_killed_the_video_capture_star.webm
157. Lightning Talks
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Wednesday/Lightning_Talks_6.webm
158. Lightning Talks
(Needs description.)
recording release: yes license: CC-BY-SA
159. Penguin Dinner Bus
(Needs description.)
recording release: yes license: CC-BY-SA
160. Plenary: What the Foo?
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/Plenary_What_the_Foo.webm
161. OFconnect: An OpenFlow Software Defined Networking Library For Everyone
Deepa Dhurka
Presented by Deepa Karnad Dhurka with Ramya Bolla
Software Defined Network (SDN) architecture has two basic elements in its simplest design - (one) controller and (many) switches. The controller is centralized and has a complete view of the network of switches. It processes control plane decisions/policies and installs forwarding rules in each switch. The switches process traffic by applying these forwarding rules. Any unknown traffic is either sent to the controller for creation of new rules or is dropped - and this too can be programmed by the controller.
The switches are connected to the controller in a “hub and spoke” topology. They talk to the controller over IP, using various transport protocols such as UDP, TCP, and TLS. OpenFlow, an SDN protocol has a Channel specification for these devices to communicate.
What if all of this communication was handled by a shared library? This would allow the designers of controllers and switches to focus on the data - the topology, the packets, the flows - and the programmability of it all.
OFconnect is an open source library created by CodeChix.org that handles network connectivity of controllers and switches. The current support includes IPv4 with TCP transport and has been integrated successfully with a controller (mul).
In this talk, I will show the basic design and architecture of the library and how you can build a controller or switch around it. Additionally, I will share how you can contribute to the library by adding a transport protocol and greater OpenFlow protocol awareness.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/OFconnect_An_OpenFlow_Software_Defined_Networking_Library_For_Everyone.webm
162. VFIO - Virtual Fabric IO a.k.a. PCI pass-through
Alexey Kardashevskiy
VFIO is a virtual fabric IO mechanism which intends to provide the
userspace access to real devices such as PCI hardware. There are 2 uses of
this:
1) a usual userspace program which knows specific PCI hardware and can use
for custom application (high speed trading?);
2) pass it to a guest OS - so called "PCI Passthrough" - and this is what
the talk is all about.
There were 2 challenges in implementing VFIO:
1. Protect guest/host memory from other guest or host.
PCI passthrough requires virtualization support from the host hardware, the
feature is called "IOMMU". Different architectures support different IOMMU
models, the existing guest systems also have different capabilities
regarding IOMMU support/requirements. Current VFIO supports x86 and POWERPC
(server and embedded).
2. Provide implementation with minimum overhead compared to the bare metal
performance when uses with KVM. This includes DMA and MMIO acceleration.
Different approaches are used for x86 and POWERPC.
3. Support tweaks/quirks which various devices might want such as
power-on-self-test and so on. Support various types of device reset is the
most annoying part of this.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/VFIO_Virtual_Fabric_IO_aka_PCI_passthrough.webm
163. OpenStack for Non-Developers
Tim Potter
Building and running a production-level cloud is a lot of hard work and can be a full-time job for dozens of people. However running a small, non-production cloud for personal or workgroup use is far less work and can yield many of the benefits of using a third party cloud service at a fraction of the cost. Most Linux distributions contain packages for a recent official OpenStack release, and this unburdens system administrators from having to deal with the vagaries of DevStack or building and installing from source. Building an OpenStack cloud service is now no longer the domain of the people who wrote the code.
This talk describes techniques, tips and tricks for building and operating a private OpenStack cloud using the StackForge chef cookbooks in the comfort of your cubicle without having to make huge investments in time or hardware. Working with different levels of support or indifference in your organisation are discussed as well as how OpenStack can be introduced bottom-up as the fantastically useful tool that it is.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/OpenStack_for_NonDevelopers.webm
164. Tales from the Trenches: Battling Browser Bugs for "Fun" and (Non-)Profit
Roan Kattouw
Web development used to be HARD. You basically had to rewrite your code for every new browser you wanted to support. But with modern browsers and libraries like jQuery, those dark days are over. Or are they? We pushed the limits of what the web can do while building VisualEditor (the new editor for Wikipedia) and found plenty of hilarious, insane, amazing and horrifying bugs in browsers, even in 2014, even without pushing the limits very hard. All we needed to do was go just a bit off the beaten path. If you're just trying to put a UI around a server-side application, the web is pretty seamless these days, but if you're trying to build an application that runs on the client, you'll find that doing interesting things in browsers is hard, even things you'd expect to be easy.
In this talk I'll share some examples of browser bugs that made us laugh (what happens if you close a tab while it's reloading?), some that made us cry (what if your ![]()
tag has no src but has an alt text?), and some where we found creative workarounds (how do you convince the browser to make box-shadows behave correctly?). I'll also talk about things that should be really simple and how hard it was to get browsers to do them right.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/Tales_from_the_Trenches_Battling_Browser_Bugs_for_Fun_and_NonProfit.webm
165. Cross-platform development in QML
Tomas Miljenovic
With Qt Quick 5, complete QML-based applications can easily be written for multiple platforms with little or no platform-specific code. Learn the basics of QML, and how to use standard controls and modules to rapidly prototype and build feature-rich and native-looking apps that run on both your desktop and your mobile device.
By the end of this tutorial, participants should have developed a functional app and deployed it to their Mer, Android, Jolla, BlackBerry, Plasma, iOS or WinRT devices.
(Upstream SDK kits for Linux will be provided on CD. Participants might prefer to install native versions of Qt Creator and QtQuick development libraries before attending, as well as any additional tools for proprietary OS deployment [e.g. XCode, MSVC] if required by your device.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Thursday/Crossplatform_development_in_QML.webm
166. The Democratisation of Radio
David Rowe
Radio is going open source in a big way.
The future of radio hardware is an antenna connected to a GPIO pin on your computer. Open source and ubiquitous MIPS will soon give you the capability to transmit and receive any waveform at any frequency. From DC to daylight. You will no longer be locked into proprietary chip sets and waveforms specified by closed source vendors and standards committees. Regulatory authorities will be facing huge challenges.
Until recently, if you needed radio, you needed inflexible and expensive hardware. Or a chip set, dominated by "closed" vendors who try very hard to limit your open source "rights" to hack. As the amount of MIPs available to us relentlessly increases, this is all changing. Radio hardware is evaporating into software. From end user applications, right down to the physical layer. This software can be open, and so inexpensive that it will be almost "free" as in beer.
Now we own the stack. This talk will explain why this is a good thing for you, open source and the world. We will explore trends in Software Defined Radio, and look where we are going in the future.
This talk will also look at the finite nature of radio spectrum, how it is regulated today, and why this model is about to be disrupted in the same way that "downloads" have disrupted the entertainment industry.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/The_Democratisation_of_Radio.webm
167. 8 writers in under 8 months: from zero to a docs team in no time flat
Lana Brindley
Twelve months ago, Rackspace had one technical writer working on their OpenStack project, running fast to stay still. Less than twelve months later, they have eight writers in Australia and the US, a world-class Agile development model, internal systems, and a fully overhauled documentation suite.
This talk covers the challenges of creating a documentation team from nearly nothing within an established software development group, while continuing to contribute and foster upstream open source documentation. All while living on the other side of the planet from Mission Control.
Lana Brindley and Alex Settle spearheaded the new team from their homes in Brisbane, Australia. They will talk about the challenges of the past eight months, and the challenges that they are yet to face, with a focus on open source and Agile documentation models.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/8_writers_in_under_8_months_from_zero_to_a_docs_team_in_no_time_flat.webm
168. Reducing GLSL Compiler Memory Usage (or Fitting 5kg of Potatoes in a 2kg Bag)
Ian Romanick
Memory is cheap these days, but, alas, it is not free. In implementing the GLSL compiler in Mesa, we prioritized debugability and ease of implementation over other concerns. In late 2013 we discovered that some large applications would exhaust virtual address space on 32-bit architectures. Techniques and tools that were used to achieve significant improvements in memory usage. What do talloc, Valgrind, uniq, and Bloom filters have in common? Come find out.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/Reducing_GLSL_Compiler_Memory_Usage_or_Fitting_5kg_of_Potatoes_in_a_2kg_Bag.webm
169. The Low Down on IRS status for Free and Open Source Software Nonprofits in the US
Karen Sandler
There has been a lot of recent press over some denials of tax exemption for US based nonprofits, while other organizations have recently been approved. Karen will discuss the tax situation in the US for free and open source software organizations. This will be a summary of the situation to date and how it impacts organizations in US going forward.
This talk will be geared at people who are interested the corporate underpinnings of free software communities. It hopefully will also help in evaluating whether or not the US is the right venue for a new organization. No prior knowledge of corporate or tax concepts is necessary, but there will be plenty of detail for nonprofit geeks!
We'll dispell some FUD about IRS determinations and give the audience members tools to evaluate their own situations.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/The_Low_Down_on_IRS_status_for_Free_and_Open_Source_Software_Nonprofits_in_the_US.webm
170. Getting More Out Of System Suspend In Linux
Rafael Wysocki
System suspend is one of the most mature and widely used power management techniques in Linux. At the same time the kernel's system suspend infrastructure is susceptible to inadvertent errors, so major changes in that code are relatively rare and applied with caution. However, that conservative approach has caused system suspend to gradually fall behind with meeting the expectations of modern systems' users. It has turned out recently that it needs to be faster, integrated more tightly with runtime PM, more careful about avoiding unnecessary operations and capable of handling systems with more advanced PM support in hardware in better ways. As a result, several efforts are under way to improve system suspend in Linux and make it even more useful. I will discuss those efforts, describe the improvements that have been achieved already and outline possible directions of future development.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/Getting_More_Out_Of_System_Suspend_In_Linux.webm
171. Deploying to the cloud with golden images, Heat and Docker
Steve Baker
Image based deployment of cloud applications is becoming a reality thanks to the growing popularity of Docker. However image based deployments bring new challenges when it comes to orchestrating and managing the life-cycle of complex container based applications.
Heat is an orchestration service that can be offered by an OpenStack cloud. This presentation will demonstrate how Heat is an ideal solution to orchestrate image based applications, whether they are packaged as Docker images or full golden images.
Image building tools such as diskimage-builder will also be presented, along with options for how to manage images in the OpenStack or Docker registries.
This presentation is focused on Heat, but is aimed at anyone who deploys applications to the cloud, whether or not they currently use Heat, OpenStack or Docker.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/Deploying_to_the_cloud_with_golden_images_Heat_and_Docker.webm
172. A methodical makeover for CTDB
Martin Schwenke
Presented by Martin Schwenke and Amitay Isaacs
CTDB is the Clustered Trivial Database (TDB) and is used to provide clustering support for Samba. CTDB is a monolithic daemon that provides several different services: clustered database, service monitoring, management of a pool of IP addresses for NAS services, various types of consistency checking... and logging. It isn't exactly monolithic - there are 2 main daemons but functionality isn't cleanly split and there is duplication. Additionally, the protocols are not well defined: just structs on the wire. Things could be better.
In an ideal world we would stop everything else we're doing for a few months, define protocols, restructure everything and, after some time, suddenly release a shiny, brand new version of CTDB. However, that's not going to happen. So, is it possible to do a major restructure of CTDB, with new protocols, in a methodical, step-by-step manner, maintaining some amount of backward compatibility as we go? With CTDB now merged into the Samba source tree, we can't break the Samba build at any stage.
What is the plan? What are the really clever ideas? Is this really possible? Join us on a hacker's tale where we describe where we started, the problems we encountered, where we got to before Linux.conf.au 2015 ... and what still needs to be done.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/A_methodical_makeover_for_CTDB.webm
173. The future of Python packaging
Richard Jones
Python packaging has been around for a while now, but recently has seen a number of improvements in tooling, support infrastructure and the packaging formats themselves. More is planned, and this talk will present the efforts currently underway with context and the plans for future work.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/The_future_of_Python_packaging.webm
174. OneRNG - An Open and Verifiable hardware random number generator
Jim Cheetham
Announced at LCA2014, the NZ-based OneRNG project has created an affordable and verifiable Open Hardware and Open Source entropy generator and RNG, presented as a USB device.
In this presentation the creators of the project will demo the device, and discuss the hardware, firmware and OS software. We will also cover trust, distrust and paranoia.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/OneRNG_An_Open_and_Verifiable_hardware_random_number_generator.webm
175. FireFoxOS and the Linux Kernel
Aimee Maree Forsstrom
FireFoxOS has entered the stage of Mobile Operating Systems and it has started to have an impact. Whilst FireFoxOS is built on components of Android it has a unique and layered architecture. But what makes it different from other mobile phone platforms and how is it using the Linux Kernel? This talk aims to explain the architecture with a strong focus on GONK (Linux Kernel) that is the HAL component of the technology stack for the platform. This is a technical talk and will aim to dive deep into how information etc is passed between layers, Bootstrapping, init and userspace processes. I will also briefly cover how to contribute to the project and where our code bases live.
There will also be some demo developer and user FireFoxOS phones to view at the talk.
What this talk is not?
This is not a talk about how to develop for FireFoxOS, or how to use the device as an end user. This talk will not cover how you can roll your own FireFoxOS build. There are many talks and resources available on the internet that cover the aforementioned areas.
What this talk is?
This talk is about the archittecual layers of FireFoxOS and is aimed at technologists who wish to understand how the project is utilsiing the Linux Kernel. The talk will cover all three layers of the architecture and how they interact and what data/inputs are passed between them.
Who it is for?
This talk is aimed at all levels of development although it dives down into how the Linux Kernel is utilised in FireFoxOS you do not need to be a Linux Kernel developer to understand the concepts that this talk will cover.
However?
This talk can be attended by anyone who is an OpenSource mobile enthusiast and wants to understand more about the FireFoxOS platform offered by Mozilla.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/FireFoxOS_and_the_Linux_Kernel.webm
176. Tunnels and Bridges: A drive through OpenStack Networking
Mark McClain
OpenStack Networking (Neutron) provides a rich set of logical constructs to develop a full featured virtual network deployment. In this talk, we will tour a basic Neutron setup and then examine how the features and capabilities provided by Linux and other open software support each of the components. We will close with look back on the new features in Juno and a look ahead to the next release.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/Tunnels_and_Bridges_A_drive_through_OpenStack_Networking.webm
177. Reverse engineering embedded software using Radare2
Andrew McDonnell
The radare reverse engineering framework, including the radare2 disassembler/analyser, is a suite of tools built around a common library, that can be used to disassemble, decompile and reverse engineer software for a large number of processors, including x86, ARM, MIPS, PowerPC, Sparc, 68000 (and even the venerable 6502!)
The radare2 software aspires to cover the functionality of a particular three letter acronym "pro" software that costs hundreds of dollars. Development is active and ongoing on github. The tool is primarly console based, and highly scriptable, with features for generating graphical reports.
This tutorial will guide you through how to use the Radare2 open source reverse engineering tool to disassemble and analyse software built for Linux on x86 PCs, and for embedded systems including MIPS-based system on chip. The tutorial includes a brief presentation on MIPS architecture and assembly and other relevant background topics.
Requirements: this is a hands on tutorial, bring your own laptop. We will be working with a version more recent than that provided by (for example, Debian Wheezy) so links to instructions will be posted to the conference chat list/wiki on how to install the software on typical Linux distributions prior to attendance. It would be advisable to do this prior to attendance so your time will be better spent learning how to use the tool. Observers still welcome!
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Thursday/Reverse_engineering_embedded_software_using_Radare2.webm
178. OpenPOWER: building an open-source software stack from bare metal
Jeremy Kerr
POWER 8 is the first generation of IBM Power Systems to run on a full stack
of open-source software. Firmware, hypervisor, operating system and
hardware-management tools are all available for audit, review and
modification.
Collectively, this software is part of the OpenPOWER project. Some of the
components (like the Linux kernel) will be familiar, but others have been
developed specifically for Power systems.
This talk gives an introduction to OpenPOWER hardware and software, and covers
the technical aspects of the stack - the components involved, what they do, and
how they interact. We'll cover how you can modify, build and run your own
firmware on an OpenPOWER system.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/OpenPOWER_building_an_opensource_software_stack_from_bare_metal.webm
179. Crypto Won't Save You Either
Peter Gutmann
Cryptographer Adi Shamir, the 'S' in RSA, once said that "cryptography is bypassed, not penetrated". In the light of the Snowden revelations about the NSA, various people have proposed using crypto in order to evade NSA surveillance. This talk tries to put that into perspective, looking at ten years of trying to secure things with crypto that ultimately failed, not through anyone bothering to break it but because it was much easier just to bypass it. The lesson from all of this is that you can't just throw crypto at something and assume that that will make you safe.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/Crypto_Wont_Save_You_Either.webm
180. Making build systems not suck
Jussi Pakkanen
It is easy to find people who will profess their love for their code editor, compiler, desktop environment or even their command line shell. It is almost impossible to find someone who truly loves their build system. The reasons for this are simple: build systems are generally perceived to be obtuse, needlessly complicated, slow or unreliable. The Meson build system was created from scratch with one simple goal in mind: every second spent writing build definitions is a second wasted. Meson tries to solve this problem by reliably providing all features required for modern software development with the least amount of effort. This presentation will show an overview of the ways in which developers can spend more time developing their software and less time babysitting their build configuration.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/Making_build_systems_not_suck.webm
181. VideoLAN, VLC and libVLC
Jean-Baptiste Kempf
VLC media player is a universal, free and open-source, cross-platform media playback and streaming application. This presentation will give an overview of the VideoLAN project, the history behind VideoLAN and VLC, the current move to mobile OS and speaking of libVLC.
VLC media player is published by VideoLAN, a French non-profit organization, and is mostly developed by volunteers in their spare time. VideoLAN’s additional products include the well-known H.264 encoder x264, specialized media streaming applications and a diverse set of libraries to support DVD and BR playback on all major operating systems. A bit of history of the VideoLAN project will be explained too.
VLC media player supports MS Windows, OS/2, Solaris, GNU/Linux, BSD and Mac OS X on the desktop; and Android, iOS and WinRT mobile operating systems. The application is licensed under the GNU General Public License version 2 and later, based upon a portable library licensed under the GNU Lesser General Public License.
The number of users of VLC is believed to be more than 100 million users worldwide, on all platforms.
The API of the VLC engine, libVLC, to develop media applications will be exposed.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/VideoLAN_and_VLC.webm
182. Herding Cats: Getting an open source community to work on the same thing
John Dickinson
Have you ever wondered how to get a big new feature completed in an open-source project? Getting people in the same company to work together can be a daunting task. Getting people to work together for a common goal when their employers actually compete with one another is quite a bit harder. Despite the challenges, the OpenStack Swift community came together to create the biggest new feature the project has ever seen.
Between June of 2013 and June of 2014, the OpenStack Swift community designed, built, and delivered storage policies, a major new feature that enables a ton of new use cases for users. This talk will briefly cover the feature implemented, but we'll mostly talk about how contributors from different companies came together and the lessons learned from that experience.
If you contribute an open source project, you'll want to hear what we did right, what we did wrong, tools we invented, tools we threw out, and how you can take these lessons we learned to your own project. We'll cover development work, review work, how we did communication, how we tracked tasks, and what we learned through it all.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/Herding_Cats_Getting_an_open_source_community_to_work_on_the_same_thing.webm
183. Pushing users into the pit of success - stories from the Samba 3→Samba 4 transition.
Andrew Bartlett
This is a talk about building complex software that 'just works' for the
vast majority of our users, lessons learned in that process and the
complexity of managing a broad project that stretches from simple
command line utilities to a whole Active Directory domain controller.
Samba needs no introduction to most attending linux.conf.au, but it is
worth explaining the full scope of the project, because our software
is certainly used well beyond our mantra of "Opening Windows to a
Wider World". Indeed, on many distributions uninstalling Samba
(specifically tdb) uninstalls the whole desktop!
Samba's progression up the stack starts with the provision of basic
libraries like tdb and talloc to client tools and libraries
(libsmbclient, libnet and others). Built on top of those are our file
server, and what we call a 'classic' domain controller, the sort of
like NT4. Further built on top of that is our Active Directory Domain
controller, including Kerberos KDC and LDAP server, and beyond that
are the hooks that projects beyond such as OpenChange reuse.
All in all, it is a complex stack, but one that we must make 'just
work', because the alternative (leave the administrator to piece
together the parts) littered with horrible failures.
Yet it is not an easy road, and has created a number of 'NIH' moments
that have become embedded in our code-base.
It is also a talk about upgrades, about unwritten and unenforced rules
and where the rules of 'of course X is always true' meets the
realities of deployed software on live networks.
This will also be a talk with a few war-stories, the rules we expected
our existing domains to honour, and how far from those expectations
our users actually were, and the steps we have taken to help even the
most idiosyncratic domain move on to become a Samba AD DC.
I will argue for software that enforces restrictions rather than
trusts that the administrator knows best. I will argue that in
complex systems, that there should be one, scripted installation route
to a working system, not a web-full of conflicting HOWTO documents,
and that a secure, centralised authentication system should be easier
to set up than the server it was installed on.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/Pushing_users_into_the_pit_of_success_stories_from_the_Samba_3_Samba_4_transition.webm
184. FLOSSing in the lab – What Plant and Food Research does with FLOSS
Zane Gilmore
Roy Storey, Ben Warren, Eric Burgueno, Zane Gilmore, and Matthew Laurenson
Plant & Food Research (PFR; www.plantandfood.co.nz) is a New Zealand government-owned research institute that directs significant effort to breeding and delivering new cultivars to industry. Breeding is a numbers game. Each year PFR produces hundreds of thousands of new plant genotypes, the bulk of which are deliberately discarded before significant resource has been invested in growing them. Some plant characteristics cannot be observed until plants have reached reproductive maturity, which can take several years. Analysing a seedling’s genetic sequence data with genomics tools provides an opportunity to identify early on whether it carries useful genes, such as those associated with disease resistance or fruit colour.
The compressed genetic sequence of a single plant can occupy hundreds of gigabytes. Generating such data is becoming cheaper every year - scientists respond by using sequencing technology more often, which increases reliance on robust data processing and management methods. Tracking sample processing requires careful identification and management of individual plants, their associated genotypes, any samples collected from those plants, and the locations of both plants and samples. PFR has developed several software assemblages to address this challenge.
"Kea", a sample handling system developed using the Python-based Django framework and an underlying postgreSQL database, helps users to manage laboratory analysis of plant samples. Kea tracks hundreds of thousands of samples through laboratory processing. It uses Elastic Search for scalable indexing to provide rapid response times for data filtering and reporting.
"powerPlant" provides scientists with the tools carry out their own bioinformatics (the science of managing and analyzing genetic data) using open source analysis tools such as Galaxy, Ensembl, and R-Studio. powerPlant employs the open source job scheduler OpenLava to allocate processing tasks from front end web servers to back end processing nodes and databases.
Open data directives like the New Zealand Government Open Access and Licensing framework (NZGOAL), Reproducible Research, and the desire to collaborate with other organisations led PFR to establish scinet.org.nz to share data sets. Each data set has a MediaWiki instance for commentary and content management, coupled with a data browsing application such as GBrowse, for manipulating and displaying annotations on genomes.
PFR now has a single 300 TB file system capable of storing large datasets, but we currently lack smart ways of processing them. We use a range of Linux-based servers with RAM ranging from 84 GB to 4 TB with 8 to 160 hyper-threaded CPU cores. Typical analyses can fully utilize even the largest of these servers. Much of current Information Technology industry activity is about "dividing the hardware" or even the OS itself into tinier chunks. In contrast, we need to identify how to divide a single process and distribute it across multiple servers to maximize resource use. Standards like Open MPI are only partially adopted and numerous bioinformatics applications don't utilize processors across multiple servers.
In the future we plan to explore using systems like iRods to automate file and metadata handling, and perhaps enable asynchronous integrations with national processing facilities like NeSI.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/FLOSSing_in_the_lab_What_Plant_and_Food_Research_does_with_FLOSS.webm
185. Vaultaire: a data vault for system metrics, backed onto Ceph
Andrew Cowie
Before you can do serious analytics you need to have serious data. You can't go averaging it away just to save space; you need the raw data.
Vaultaire is a distributed metrics store. It is fault tolerant, performs well, is space efficient, and — since it stores data directly in Ceph — scales horizontally as your cluster grows.
Most systems crumble when faced with the thousands of metrics per second typically being gathered in a production environment. Ceph is good at absorbing lots of writes, and is especially good at handling randomly distributed reads.
You may have experienced Ceph via it's S3-compatible HTTP gateway or via the RBD block device service. You may not know these are built atop a simple library that handles talking to the storage cluster and locating your data, librados, and that's how Vaultaire stores its time-series data.
Using librados directly opens some pretty cool possibilities. It's powerful, but low-level, and as you'd expect there are gotchas. We'll talk about building a librados-based application, lessons learned relying on Ceph in production, and the challenges of building predictive modelling tools on top of a metrics store that doesn't throw data away.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/Vaultaire_a_data_vault_for_system_metrics_backed_onto_Ceph.webm
186. Who is Linux Australia
Joshua Hesketh
Linux Australia is the peak body for Open Source communities in Australia. LA represents Australian users and developers of Free Software and Open Technologies, and facilitates internationally-renowned events including linux.conf.au -- Australasia's grassroots Free and Open Source Software Conference.
In addition to running half-a-dozen conferences a year the community works on lobbying to regulatory bodies, helping free software development through sponsorship, granting the community and individuals funds, advocacy for open source and much more.
Despite the organisation's success there are a lot of people who are unfamiliar with the organisation and what they do. In this talk the President, Joshua Hesketh, will cover what the organisation does, how it operates and how to become involved.
We will look at the various teams, subcommittees and individuals that make up the organisation. Going into detail about their roles+responsibilities, the internal processes+tools and the challenges+outcomes of the hard work.
LA is a volunteer organisation made up of a lot of awesome, hard-working, people. In this talk the audience will hopefully get a better insight into the community and be encouraged to become involved themselves.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/Who_is_Linux_Australia.webm
187. Bare-Metal Multicore Performance in a General-Purpose Operating System (Adventures in Ubiquity)
Paul McKenney
Database, high-performance computing (HPC), and real-time developers have often asked: "Can't you get the kernel out of the way?". Recent adaptive-idle work permits just that: Linux is there when you need it, but if you follow a few simple rules, it is out of your way otherwise. This approach will provide bare-metal multicore performance and scalability to databases as well as to HPC and real-time applications.
A key part of any project is validation. Now some people will tell you that Linux-kernel testing doesn't really start until Fengguang Wu subjects your code to his 0-day testing. Other people will say that testing doesn't really start until Stephen Rothwell does -next integration testing. Still others claim that testing doesn't really start until your code is accepted into mainline. Yet other people claim that testing doesn't really start until the distros run their entrprise test suites. But I am here to tell you that testing doesn't really start until your code is enabled by default by major distros. At that point, your code becomes ubiquitous, which means that (through no fault of their own!) people start using your code for purposes you had not fully considered, which is usually an excellent way to find new and different corner cases that your code does not yet handle properly. This talk will describe a few interesting adventures with a few surprising corner cases.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/BareMetal_Multicore_Performance_in_a_GeneralPurpose_Operating_System_Adventures_in_Ubiquity.webm
188. Drupal8 outta the box
Donna Benjamin
Drupal 8 is coming.
This tutorial will give you hands on experience with the newest version of Drupal. If you haven't had a look for a while, now is the time to revisit the drupalverse.
We will build a website from scratch and learn how to participate in one of the open source world's largest communities.
Note: To participate in this session you will need a laptop!
Be sure to check out the wiki for more of an outline on what we'll be covering. linux.conf.au/wiki/Tutorials/Drupal8_outta_the_box
recording release: no
189. Programming Considered Harmful
Dave Chinner
I recently came across a statement on LKML:
'
> Reviewed by:
I'm not looking for reviews - I'm looking for testers.
'
As an engineer, this struck me as fundamentally wrong. The ensuring discussion over whether the definition of "free of known issues" meant that the reviewer needed to apply and test the patch was not very rewarding.
In the discussion, the academic peer review model was cited as the reason that reviewers don't need to test the code they review - reading the change is enough to find all known problems. My response was that software engineering code review requires the reveiwer to perform due diligence and that implies a reviewer must apply, test and verifying the code under review. These are very different views on what is supposedly a well defined process.
A further commenter quoted Dijkstra, mocking my views on software engineering process:
'If you carefully read its literature and analyse what its devotees
actually do, you will discover that software engineering has accepted as
its charter "How to program if you cannot."'
During this talk, I will demonstrate that humans cannot Program. There is evidence *everywhere* that we fail badly at Programming and we repeatedly demonstrate that our attempts to Program don't improve as complexity increases. Using examples from the Linux Kernel, I'll state my case for why I think we should be engineering complex software rather than Programming, and how that impacts on our code design and review processes.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Thursday/Programming_Considered_Harmful.webm
190. Wiki New Zealand: Winning through collaboration
Lillian Grace
No country can claim that their people are able to make most of their important decisions in an evidence-based way. There are hundreds of valuable and relevant datasets freely available to us right now but most people don’t use them. Data is spread across hundreds of sites and is held within databases and spreadsheets that require both time and skill to engage with. To use data in decision-making you have to know what specific question to ask, identify a source that has collected the data, and manipulate complex tools to extract and then visualise the information within the dataset.
The barrier to entry is high. It means that when we do see data in digestible, visual forms (i.e. graphs and thematic maps), it is usually because somebody is trying to convince us of a particular point of view. Whilst that is a very legitimate use of data, it is not sufficient for having a well-informed country.
Wiki New Zealand is working to make data truly accessible to all. We are doing that by collaborating throughout New Zealand’s data ecosystem to create a platform that not only brings all the data together in one place, but that makes it visually explorable. Making the data visual lowers the barriers and transaction costs of engagement, and speeds up the process of generating insight.
By bringing data to the people in a usable way we are creating a competitive advantage for New Zealand.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Thursday/Wiki_New_Zealand_Winning_through_collaboration.webm
191. Considering the Future of Copyleft: How Will The Next Generation Perceive GPL?
Bradley Kuhn
Copyleft licenses, particularly the GPL and LGPL, are widely used throughout the Free Software community. However, recent for-profit corporate interest in Free Software development has led to a renewed preference toward non-copyleft licensing. Meanwhile, many for-profit entities that do use copyleft for their own software now do so in a manner that most copyleft aficionados find, at best, distasteful and at worst, abusive.
A long-standing truce once existed in our community between fans of non-copyleft licensing and copyleft, but as the community has grown, that truce has mostly disintegrated. While no one in the copyleft communities disputes that non-copylefted Free Software is an important part of our community, copyleft faces new challenges that make past debates about the appropriateness of copyleft seem minor by comparison.
This talk discusses all aspects of the complicated situation that copyleft now faces, including younger developers apparent preference for non-copyleft licensing (as expressed, in part, in the so-called “post-open source” debates), the widespread and common failures in GPL compliance, and how licensing choices are today — unlike in the past — rarely in the hands of individual developers, but instead their corporate employers.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Thursday/Considering_the_Future_of_Copyleft_How_Will_The_Next_Generation_Perceive_GPL.webm
192. IPMI - because ACPI and UEFI weren't terrifying enough
Matthew Garrett
ACPI was dreadful and scary, and it's still scary but at least it mostly works now. UEFI jeopardised the interests of our entire tribe, but we got through it. How could any other four letter specification worry us?
Meet IPMI - the Intelligent Platform Management Interface. A protocol that allows admins to power machines on and off remotely. A protocol that permits remote querying and reporting of hardware errors, fan speeds, temperatures and more. A protocol so poorly designed that it explicitly defines passwordless authentication. A protocol that's generally implemented by gluing a small insecure embedded Linux device to your server motherboards. A protocol implemented by people who don't understand the importance of avoiding leaking bits of the heap in network packets. A protocol that's frequently exposed to the public internet. A protocol that's… well. You get the idea.
This presentation will cover the IPMI protocol and its potential uses for good, along with a deep, dark, depressing discussion of its despair-inducing failings at both the protocol and implementation levels. You'll laugh. You'll cry. You'll never trust your servers again.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Thursday/IPMI_because_ACPI_and_UEFI_werent_terrifying_enough.webm
193. Connecting Containers: Building a PaaS with Docker and Kubernetes
Katie Miller
co-presented with Steve Pousty
Learn how Red Hat is using Docker and Google's Kubernetes project to redefine modern application platform services. New container-centric tools for managing resources in the cloud have helped to establish new best practices, prompting a redesign of Red Hat's open source OpenShift Platform as a Service. This talk will give an overview of Docker, Kubernetes and the container-focused Atomic OS, and explain how these open source building blocks have been used to create the next generation OpenShift V3 PaaS.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Thursday/Connecting_Containers_Building_a_PaaS_with_Docker_and_Kubernetes.webm
194. PDNS Bus
(Needs description.)
recording release: yes license: CC-BY-SA
195. PDNS
(Needs description.)
recording release: yes license: CC-BY-SA
196. LCA Social at PDNS Venue
(Needs description.)
recording release: yes license: CC-BY-SA
197. Keynote: Linus Torvalds
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/Keynote_Linus_Torvalds.webm
198. How to get one of those Open Source jobs
Mark Atwood
Getting paid to work on open source is sometimes called “living the dream”. People with skill sets in open source development are in high demand, can have good salaries, and often can work from home, with opportunities to work with excellent coworkers, on projects they enjoy. I will present advice and lead discussion on what the necessary hard skills and social skills are, how to get them, and how to gain the necessary social proofs and reputation, and how to curate a portfolio.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Friday/How_to_get_one_of_those_Open_Source_jobs.webm
199. Open Source Protocols and Architectures to Fix the Internet of Things
Alasdair Allan
Everyday objects are becoming smarter. In ten years’ time, every piece of clothing you own, every piece of jewellery you wear, and every thing you carry with you will be measuring, weighing and calculating your life. In ten years, the world — your world — will be full of sensors.
The problem? The things are becoming smarter, but they’re also becoming selfish. Your lightbulbs aren’t talking to your media centre, your media centre isn’t talking to your blinds, and nobody is talking to the thermostat. Instead of talking to each other, everything is talking to you—you’ve ended up as a mechanical turk inside someone else’s software.
That situation can’t continue, we need to fix the Internet of Things. As our computing continues its diffusion out into the environment we need our things to work together. The things have to become not just smarter, but more co-operative, they need to become anticipatory rather than reactive.
Right now we have not so much an Internet of Things, but a series of Islands of Things. I present open source protocols and architectures that will help solve this trouble with the Internet of Things.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Friday/Open_Source_Protocols_and_Architectures_to_Fix_the_Internet_of_Things.webm
200. All your multimedia are belong to us
Diego Biurrun
Ever watched a video on YouTube or Vimeo? Played a file with VLC or MPlayer? Enjoyed multimedia on your Linux desktop?
Of course you did; but did you hear about the libavcodec library before, the engine behind most FOSS and many proprietary multimedia applications and services? Do the names FFmpeg and libav ring a bell, but you wonder what happened since the fork in 2011 and why?
This talk will give an overview of the centerpiece project(s) of FOSS multimedia. Where and in which ways you are using it all the time; how it all started, where it is today, why it took so many flames to get there, how we surmounted all legal obstacles, and whether or not the future will bring total world domination.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Friday/All_your_multimedia_are_belong_to_us.webm
201. Servo: Building a Parallel Browser
Jack Moffitt
Servo is an experimental browser engine for modern multi-core hardware written in an experimental memory safe language called Rust. Current browsers were designed over a decade ago when phones were not smart, clock speeds were still increasing, and web pages were still static. Taking advantage of modern amenities requires a new approach.
Servo is written from scratch to be parallel at every level. It uses CPU and GPU, multiple tasks per functional unit, fork-join concurrency, and SIMD, and the team is not done yet.
Browser security is paramount, both to prevent attacks and to solve in such a way that vulnerabilities are difficult for programmers to introduce. Servo uses Rust and its advanced type system to help overcome the status quo of C++ code.
I'll talk about Servo's goals, its design, and how the Rust language is
helping. I'll discuss where it is possible to get more parallelism in the
browser, especially in its layout algorithms, and how we plan to do it.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Friday/Servo_Building_a_Parallel_Browser.webm
202. Some things you can do with a recurrent neural network
Douglas Bagnall
In 2013 I wrote a Gstreamer plug-in that used a recurrent neural network (RNN) to generate video in imitation of a program it was watching. Pretty soon the same RNN library was being used in another Gstreamer plug-in to classify speech on the radio according to language, and to detect birds by listening for their calls (the language classification is quite accurate and runs at 1500 faster than real time on an old laptop, which is at least a data-point for those wondering about spying capabilities). The RNN has also been used to generate text and code, and to classify text by language and author at a fine-grained level. I will show how the RNN is trained, and how it might be adapted for other forms of time-series data.
I will demonstrate the various plug-ins and text utilities and, for excitement, execute RNN-generated code on the fly. Also I'll explain what a recurrent neural network is and how it relates to a plain (or "deep") neural network.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Friday/Some_things_you_can_do_with_a_recurrent_neural_network.webm
203. A CoreOS Tutorial
Brandon Philips
Get ahead of the curve and learn new ways to deploy and manage applications at scale. This tutorial will introduce you to CoreOS and its key components, including etcd, fleet, docker and systemd. Leave using these technologies to deploy and build performant, reliable, large distributed systems. This tutorial will walk you through how to:
Provision a CoreOS cluster
Build your first container
Manage configuration with etcd
Create systemd unit files
Launch containers with fleet
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/A_CoreOS_Tutorial.webm
204. When Your Codebase Is Nearly Old Enough To Vote
Denise Paolucci
As time marches on, more and more FLOSS projects are reaching ages that qualify them as 'venerable'. On the one hand, that rich history of constant improvement provides a robust framework upon which to build. On the other hand, that can lead to sections of the code marked "here be dragons" that haven't been touched in this millennium, and the ever-accelerating speed of technology's march can leave you with a balance-sheet of technical debt that would make anyone quail.
This talk is a case study of Dreamwidth Studios, forked in 2008 from LiveJournal.com, a project that began in 1999. With a quarter-million lines of legacy Perl, it's been hard to decide what to modernize and what to leave alone. Come hear our successes, our failures, and a few horror stories of disasters we've stumbled into along the way.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Friday/When_Your_Codebase_Is_Nearly_Old_Enough_To_Vote.webm
205. High-Performance and Scalable Updates: The Issaquah Challenge
Paul McKenney
Highly performant and scalable techniques such as RCU have been quite successful in read-mostly situations. However, there do come times when updates are necessary. It would be convenient if there was some general update-side counterpart to RCU, but sadly there is not yet any such thing. Nevertheless, there are a number of specialized update-side techniques whose performance and scalability rival that of RCU. This talk will discuss several of them and provide an outlook into the future of low-overhead scalable updates.
One technique is the solution to the Issaquah Challenge, which was put forward at the C++ standards committee meeting in early 2014 at Issaquah, WA, USA. This challenge requires a performant and scalable technique to atomically move elements back and forth between a pair of search trees, but without using transactional memory. This talk will give an overview of a solution to a more general problem, that of atomically moving groups of elements among a group of several different types of linked data structures, while still permitting lockless searches before, during, and after this atomic move.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Friday/HighPerformance_and_Scalable_Updates_The_Issaquah_Challenge.webm
206. Open-source OpenGL on the Raspberry Pi
Eric Anholt
This talk will describe the state of Mesa and kernel driver development for the Broadcom VC4 graphics chipset present in the Raspberry Pi.
The specs for this chipset were released in February, and I started development on the driver in June. It's a GLES2-only part, which is significantly simpler than most of the hardware that Mesa supports, but that also brings its own challenges for building a complete Linux desktop experience, since it doesn't support some of the primitives, texture formats, and shader instructions we've always had available. In addition, the hardware sits directly on main memory without an MMU in between, so command and shader validation is required in order to prevent privilege escalation. I'll discuss these and other challenges faced and the workarounds I've found.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Friday/Opensource_OpenGL_on_the_Raspberry_Pi.webm
207. Pettycoin: Towards 1.0
Rusty Russell
Pettycoin is an adjunct network for tiny bitcoin transactions. It was first unveiled in slightly vaporous form at LCA2014, but since then I've taken a 6 month sabbatical and spent much more time on it.
The bitcoin network is powered by "miners" who compete to work on proofs. This infrastructure is expensive, and places a lower limit on how cheap transactions on the bitcoin network can become. For genuinely tiny microtransactions, various schemes have been proposed to operate off-network temporarily; pettycoin aims to do this in a general and open way, using the same work the bitcoin miners are already doing.
The talk has two parts: the first part is about the technology itself, and the second part is about founding and managing a "for fun" FOSS project in a space which is crowded with many good ideas and even more VC money chasing them.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Friday/Pettycoin_Towards_10.webm
208. Ask Away: Staking Out the Stakeholders
Meg Howie
Ask Away is a web application which aims to make it easier for young people to get informed and involved in elections. It is a question and answer platform where the public can ask New Zealand’s political parties questions in the lead up to the 2014 General Election.
This project has stakeholders from academia, mainstream media, open source developer communities, parties from across the political spectrum and not for profit organisations. User-centred and user experience design techniques were used not only to meet the needs of end users, but to cater to each of these stakeholders and get them contributing to the project.
The initiative is housed within Massey University’s Design & Democracy project, a strategic research unit within the College of Creative Arts. This is the first open source software project to be funded by CoCA, and I will discuss how that came about as well as the design methods that were used to enable collaboration across this broad range of stakeholders.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Friday/Ask_Away_Staking_Out_the_Stakeholders.webm
209. When Everything Falls Apart: Stories of Version Control System Scaling
Ben Kero
At Mozilla we have a great dependency on version control systems and software. All contributors format patches against it, all of our build automation infrastructure pulls from it, all online collaboration links against it. Over the life of various Mozilla projects, we've shifted version control systems many times, which led us to being large users of a multitude of systems: Git, Mercurial, CVS, SVN, BZR, and even RCS.
Over the years we've also developed bizarre sets of hooks and various externally-hosted barnacles that promise to add greater insight into incoming code, along with notifications and beautiful graphs to keep all the developers up-to-date with the status of the project and to keep the PHBs (pointy-haired bosses) happy with the progress of overall development.
In keeping up with this massive demand of hundreds of thousands of checkouts/clones per day, we've had to do heavy capacity planning in terms of hardware (the easy part). The hard part has been trying to scale the backend version control server software, which has led us into some interesting problems that haven't been discussed or shared at length of in detail in a public setting.
In particular this talk will be about about experiences and trials that we've faced keeping reliabile, quick response times, and general uptime of the Git and Mercurial version control systems.
Join me as we explore when, how, and how often these systems break, how to properly monitor and diagnose them, critical caching failures, backend-switching shenanigans, grumpy upstream correspondence, NFS atomicity being sketchy, and lots of throwing hands into the air and ragequitting.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Friday/When_Everything_Falls_Apart_Stories_of_Version_Control_System_Scaling.webm
210. Government as an API: open {data|source|standards}
Pia Waugh
Government as an API is about being able to create services and information that span departments, jurisdictions and the world. Pia will speak about how the opening up of data, systems and software make it easier for citizens, industry and indeed, governments to aggregate services and information to better serve the needs of society. It means governments don't need to try to be everything to everyone, but rather can provide the digital building blocks for a more cooperative and collaborative approach to tackling the challenges and opportunities of our time. Governments, in short, have a lot to learn from the Open Source community.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Friday/Government_as_an_API_open_datasourcestandards.webm
211. Building Services in Go
Mark Smith
Following on from last year's Introduction to Go tutorial, this talk will cover building a production service using the Go programming language. By the time you walk out of this talk you will have built a real service capable of supporting 10,000 simultaneous clients. You will have the tools necessary to go out and build your own services for your own projects.
Along the way, we'll talk about some good practices for building systems in Go, services in general, and also some things you have to think about when working at this scale. Consider it a quick-and-dirty education in building highly concurrent software that's supposed to run safely and stably for long periods of time.
About Go: A relatively new programming language built by some pretty smart engineers at Google, Go is a statically typed, compiled language that is particularly well suited for writing services in Internet-scale environments. Compared to other common contemporary languages, Go is an amazing platform for writing highly concurrent applications that serve tens of thousands of clients (or more).
Requirement: You should either be familiar with Go or a pretty quick study on languages. The talk starts at a level that should work for people who have done Intro-to-Go tutorials before or written small programs.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Friday/Building_Services_in_Go.webm
212. Flying with Linux
Andrew Tridgell
The port of ArduPIlot to Linux is now flying, bringing us one step closer to Linux dominating the world of small UAVs.
Last year I presented a plan to port ArduPilot to the BeagleBoneBlack board by building a new "PXF" cape that gives the BBB a wide range of high quality sensors. That cape has now been built, and an ArduPilot port has been done. Linux on the BBB can now fly/drive a wide range of vehicles.
In this talk I will describe the architecture of the BBB port of ArduPilot, including how the PRU co-processors are used, how we interface to SPI and I2C devices and the development tools we have developed to make life a bit easier for those wanting to work on Linux based autopilots.
I will also give an update on the CanberraUAV 2014 Outback Challenge entry, and on some other current efforts to bring autopilots to more Linux based boards.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/Flying_with_Linux.webm
213. Advanced Linux Server-Side Threats: How they work and what you can do about them
Olivier Bilodeau
Server-side malware has evolved. Attackers used to be motivated by defacement or direct damage, using small-scale and targeted operations. Nowadays we are seeing an increase in organized crimeware campaigns leveraging compromised Linux servers for financial gain through website redirections infecting end-users and spam. Furthermore, malicious gangs base their operation's infrastructure on these same compromised servers, making takedown or law enforcement intervention complex since they run legitimate workloads.
This presentation will cover the evolution of the financially motivated Linux malware and will describe the threats that were part of Operation Windigo which affects more than 25 000 servers. We will give in-depth technical details on the pieces of malware involved, show how they are deployed by the operators and how they are able to defeat current defensive technologies. More importantly, we will describe hands-on detection and incident response tricks to quickly assess one's servers and help in the fight.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Friday/Advanced_Linux_ServerSide_Threats_How_they_work_and_what_you_can_do_about_them.webm
214. Surrounded by Graphs - a short introduction to Graph Databases and Neo4j
Julian Simpson
From social networks to IP address allocations to Makefiles, we're all surrounded by graphs. Graph data structures are an increasingly helpful approach to modelling and storing your data.
This presentation will introduce Graph Databases in the form of Neo4j, an open source Graph Database. Neo4j has been an open source project since 2007, though it was originally used before then in production at a private company in Sweden. Neo4j sports a humane query language called Cypher, which will be demonstrated in the presentation.
Several modelling examples will be demonstrated with working examples taken from the world around us.
The attendee will learn:
* The difference between a graph and a chart
* What a Graph Database is
* How Graph Databases compare to other NoSQL databases
* How to create a simple graph to store (and query) data in Neo4j
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Friday/Surrounded_by_Graphs_a_short_introduction_to_Graph_Databases_and_Neo4j.webm
215. SL[AUO]B: Kernel memory allocator design and philosophy
Christopher Lameter
An introduction to the design and ideas behind the 3 small object memory allocators in the Linux kernel. SLAB is the original memory allocator based on ideas also used for Solaris. SLOB is a based K&R allocator originating even further in the past. SLUB is an allocator written for minimal queuing focusing on low instruction overhead in the fast paths instead.
Slab allocators are providing basic memory allocation to kernel code. Often these allocations may occur in performance sensitive code (especially in the network and storage layer). Kernel performance is significantly affected by the slab allocators architecture and features. The talk provides an overview of the slab allocator services available in the Linux kernel and covers the most frequent use cases. The approaches used in the three slab allocators (SLAB, SLUB, SLOB) are compared and ways to get the maximum performance out of each of them are presented. Lastly a series of common gotchas when using slab allocators are reviewed followed by an open discussion on issues and the future of the slab subsystems.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Friday/SLAUOB_Kernel_memory_allocator_design_and_philosophy.webm
216. FreeIPA: Open Source Identity Management
Fraser Tweedale
Identity management and authorisation are complex problems, and many
disjoint technologies have emerged as a result - but software should
be making life easier for users and administrators. When it comes
to GNU+Linux in the enterprise, what is our answer to Active
Directory?
FreeIPA is an integrated identity management solution providing
centralised user, host and service management, authentication and
authorisation in Linux/UNIX networked environments, with a focus on
ease of deployment and management. It is built on top of well-known
Open Source technologies and standards including 389 Directory
Server, MIT Kerberos and Dogtag Certificate System.
This talk will cover the basics of FreeIPA - the main features it
provides (and why those features matter), the deployment process,
how to enrol clients in the domain, and interoperability with Active
Directory and other technologies - and will conclude with a look
ahead to what's on the roadmap.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Friday/FreeIPA_Open_Source_Identity_Management.webm
217. SD Cards and filesystems for Embedded Systems
Peter Chubb
Modern embedded systems (such as your Android phone) extensively use SD cards for secondary storage.
You can buy a cheap 32G microSD card for under $16 --- or you can spend $100s on an ultra-high-speed card.
Does it make a difference to your phone's performance? Can filesystems be tweaked to get better performance on cheap cards?
We've been benchmarking some cards, with different filesystems (including the new F2FS that is intended for optimal performance on SD cards) on a variety of embedded systems.
Short answer: it makes a difference, but you can get 90% of the bang for 15% of the buck if you're prepared for a bit of work.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Friday/SD_Cards_and_filesystems_for_Embedded_Systems.webm
218. Hacking 3D Printers
Vik Olliver
Open 3D Printers print plastic, right? Well, mostly, but that's boring. What you probably want them to do is to print metal, make stuff out of chocolate, and strap lasers to their frickin' heads.
The whole point of making Open Source 3D printers was to provide a platform which could be hacked. A platform that could do whatever you wanted it to do. This presentation shows them not as extruders of plastic snail-trails, but as versatile 3D robots eager to grasp new tools and do your bidding with them.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/Hacking_3D_Printers.webm
219. Mixing In The Free World
Mike Tarantino
There are an impressive number of talented musicians amongst free and open source software geeks. Grammy-nominated recording engineer Mike Tarantino gives a hands on look at mixing music. Using Ardour, a popular free software Digital Audio Workstation, we'll look at setting up your mix and demo some specific mixing techniques to address common problems and give a more professional sound. This will include some basic how-to and is a follow-up to last year's LCA session, Rockin' In The Free World. Let's mix!
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Friday/Mixing_In_The_Free_World.webm
220. Why can’t we be friends? Integrating Security into an Existing Agile SDLC
Laura Bell
Agile development is often seen as a delicate balance of ritual and roles allowing for rapid development, continuous deployment and the expansion of the post-it note industry.
Security is often seen as a lumbering giant of process, governance and technology allowing for increased control, reduced risk and the expansion of the technology vendor industry.
What if you could merge the two? No really! What if these two former polar opposites can be made to play nicely together?
The world of security is changing to meet the needs of agile software development. Organisations around the world are coming up with tools, techniques and processes to make security a continuous presence to support developers.
In this talk I will outline the questions and challenges involved with implementing security in an agile SDLC, outline some techniques and tools that you can use and share some lessons learned from my journey so far.
So whether you are a shiny new start-up wanting to secure development from the beginning or you are an existing company with years of well-earned technical and security debt ; This talk is for you.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB3/Friday/Why_cant_we_be_friends_Integrating_Security_into_an_Existing_Agile_SDLC.webm
221. How to train your Minions
Thomas Sprinkmeier
Most people experience technology as something that's branded, shrink-wrapped, assembled with custom screws and on a monthly contract. We're surrounded by these wonderful possibilities, but denied from realising their full potential by business models dating back to the last millennium.
I'd like that to change. But I can't do it alone.
I've got a plan.
Since 2010 I've been volunteering in classrooms and scout halls. Under the guise of teaching Geekology to kids I've actually been training an army of minions to help me keep technology open, accessible and fun.
Last year I moved my base of operations from various classrooms and halls to my New Evil Lair (formerly known as the Office Lunch Room).
Minions are trained to be self-reliant, assembling and installing their own computers. Survivors move on to specialist classes in combat (Scratch) and Monster-keeping (Python), BlinkenLights (Arduino) and graduate to design and manufacture of Doomsday Devices (3D printing).
While I feel I have made good progress, a one-overlord crusade against the forces of good is a lonely venture. I'd like to encourage others to take up the mantle (or cape, or overcoat, whatever matches your shoes) and start training their own minions.
My talk will address some of the difficulties in setting up a minion training academy.
Whilst I managed to overcome most of these (like funding and a venue) using luck rather than skill, it is my hope that I can at least pass on lessons on what not to do.
I will also address some of the challenges for the future, such as amassing a more gender-balanced army of minions to better infiltrate society, and finding a mostly-extinct Volcano with good internet connectivity.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/How_to_train_your_Minions.webm
222. NoOps with Ansible and Puppet
Monty Taylor
Four years ago, I started a running my first in-cloud project, and I did it as naively as possible - I used the cloud API to get a machine, and then I ran and administered that machine the same way I've adminned every other machine for the past 20 years. As I started adding machiens, it became clear that now was the time to learn this new fangled puppet stuff.
Puppet turned out to be wonderful for repeatability, but the fine folks who wrote it had some really weird ideas about what sorts of things I wanted their help with and what sorts of things I didn't. For instance, I don't really think that it should take 100 lines of a weird DSL to add a user with an SSH key.
Fast forward to today, and we have a control plane of 76 nodes and an elastic pool that runs around 1000 nodes, but creates and destroys between 10k and 20k machines a day. Ths is currently done using a combination of Ansible, Puppet and custom written management tools, and is run automatically continuously deployed from our master branch with every aspect of the deployment being 100% open and Open Source. That is - any of you can go submit a patch to our git repo and if we land it, it will immediately change the running production system - and that's the only way the system gets changed.
While we'll use our current system as an example case to talk about concretely (since it's open source and all) the main point of this talk will be to talk about how to use modern tools ot admin systems efficiently and without throwing away any of the old Linux knowledge we all have.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_260098/Friday/NoOps_with_Ansible_and_Puppet.webm
223. Botching up IOCTLs
Daniel Vetter
One clear insight kernel graphics hackers gained in the past few years is that trying to come up with a unified interface to manage the execution units and memory on completely different GPUs is a futile effort. So nowadays every driver has its own set of ioctls to allocate memory and submit work to the GPU. Which is nice, since there's no more insanity in the form of fake-generic, but actually only used-once interfaces. But the clear downside is that there's much more potential to screw things up.
To avoid repeating all the same mistakes again this talk will present some of the lessons learned while botching the job for the drm subsystem in general and the i915 driver specifically. Topics covered will be the bare basic to avoid needless busywork later on, reasonable minimal testing to avoid CVEs and other embarrassement. And generally a thicket of war stories to figure out what works and where's still some white spots in the userspace interface landscape.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_2/Friday/Botching_up_IOCTLs.webm
224. Sustaining Momentum - or the Gap Between User Request and Developer Capacity
Dirk Hohndel
Open source projects go through an interesting life cycle. It usually starts with an idea. Often driven out of a personal need (or want) by a small number of people - maybe one or two or a handful. What follows is the early phase, culminating with the first reasonably useful release (which often is not necessarily the /first/ release).
If the project is interesting and speaks to more people the team can hope to gain more developers, come out with a more refined sequence of releases until the project gets to the point where it is fulfilling the needs of the people who started it. This is where things get interesting. Does development slow down and stagnate? Does it gain lots of user and consequently gets overrun by support and feature request? Is it able to attract more developers to stem that tide?
This talk will focus on that phase of a product, on the balance between gaining users, gaining developers, understanding what the project needs to grow and when and where it is important to say no.
Subsurface will be used as one of several examples for this process, but this talk is less about Subsurface and more about the process of running an open source project.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/Case_Room_3/Friday/Sustaining_Momentum_or_the_Gap_Between_User_Request_and_Developer_Capacity.webm
225. Grace: an open-source educational programming language
Michael Homer
Grace is a new programming language aimed at education. Grace intends to reflect the last two decades' accumulation of knowledge on language design and teaching, and integrates well-known features that have proved themselves useful in other languages. Grace permits multiple approaches to program design and teaching, including object-, class-, procedure-, and function-based programming, with or without types, and allows moving between these approaches within the same language, so that students can be exposed to multiple approaches and instructors can tailor their courses to the topics they wish to teach.
Supporting users at different stages of understanding is a key goal of Grace. While the main purpose of Grace is to be used for introductory programming courses, it is also a full-powered language incorporating the state of the art in language design. Different approaches and different levels of learning are supported by a feature called dialects: extended and restricted user-defined sub-languages applied on a per-module basis. Through dialects a learner need only see the functionality that is relevant to their stage of learning, with other features that might confuse the issue hidden, and can gradually move to an unrestricted language.
In this talk, I'll outline the principal features of Grace and the philosophy behind them. I'll discuss the design choices made and the paths not taken, and describe the remaining open issues of the language. I'll talk about where language design can help programmers say what they mean, and talk particularly about the interesting pattern-matching and dialect features in Grace.
I'll also look at what educational research tells us about learning to program and programming languages. I'll outline how that has influenced the design of Grace. In the same vein, I’ll give some examples from the design process so far showing how conceptually orthogonal design decisions turn out to be deeply interrelated and require careful balancing with the goals of the language. I'll mention preliminary trials using Grace educationally.
Grace has two existing open-source implementations. I'll introduce both of these, the self-hosted Minigrace compiler and the concurrent JavaScript-based Hopper interpreter. I'll also demonstrate a unique interface built on them that integrates visual programming à la Scratch and textual programming for the same code, to achieve a smoother transition for even earlier programmers.
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB4/Friday/Grace_an_opensource_educational_programming_language.webm
226. Conference Closing
(Needs description.)
recording release: yes license: CC-BY-SA
227. Conference Closing
(Needs description.)
recording release: yes license: CC-BY-SA
Video: http://mirror.linux.org.au/linux.conf.au/2015/OGGB_FP/Friday/Conference_Closing_2.webm
228. Keynote (HD 720p): Linus Torvalds
Linus Torvalds, Bdale Garbee, Andrew Tridgell, Rusty Russell
Way, way back in 2003, at LCA in Perth, there was a Q&A session with Linus Torvalds, Bdale Garbee and Andrew Tridgell. It’s time for a follow-up so at LCA 2015 in Auckland it’s going to happen!
The Q&A session is scheduled for 09:00 am Friday, 16 January 2015 and will be moderated by Bdale Garbee with the assistance of Andrew Tridgell.
Helsinki-born Linus, who simply calls himself a Software Engineer, was the principal force behind developing the Linux kernel. It all started from an initial usenet posting in August of 1991 and made what has proved to be a historic debut with the release of version 1.0 on March 14 1994.
In June 2003 Linus started working for Open Source Development Labs. After merging with the Free Standards Group it became the Linux Foundation where Linus continues to work as the project’s coordinator and is Chief Architect of the Linux kernel.
In 2005, after criticism for his use and alleged advocacy of BitKeeper, proprietary software for version-control in the Linux kernel, Linus wrote a free-software replacement for BitKeeper called GIT which is now the most widely-adopted version-control system for software development.
Linus is an accomplished diver and in 2011, frustrated with the lack of decent divelog software on Linux, he developed Subsurface (http://subsurface-divelog.org/) an Open Source divelog program that runs on Windows, Mac and Linux.
We know that there are a number of beautiful diving spots not too far from Auckland...
The LCA 2015 Auckland team would like to thank the Linux Foundation for their assistance in making this possible.
recording release: yes license: CC BY-SA
229. Keynote (HD 720p): Eben Moglen
Eben Moglen
The LCA 2015 team is honoured to announce our first Keynote speaker - Professor Eben Moglen, Executive Director of the Software Freedom Law Center and professor of Law and Legal History at Columbia University Law School.
Professor Moglen's presentation is scheduled for 09:00 am Tuesday, 13 January 2015
Professor Moglen has represented many of the world's leading free software developers. He earned his PhD in History and his law degree at Yale University during what he sometimes calls his “long, dark period” in New Haven.
After law school he clerked for Judge Edward Weinfeld of the United States District Court in New York City and for Justice Thurgood Marshall of the United States Supreme Court. He has taught at Columbia Law School since 1987 and has held visiting appointments at Harvard University, Tel Aviv University and the University of Virginia.
In 2003 he was given the Electronic Frontier Foundation's Pioneer Award for efforts on behalf of freedom in the electronic society.
recording release: yes license: CC BY-SA
230. Plenary (HD 720p): What The Foo?
Cooper Lees, Carol Smith, Mark McLoughlin
On Thursday, as part of our taking a different approach to keynote sessions for linux.conf.au 2015, we’re offering representatives from 3 leaders in open source to give us their “15 minutes of foo” to start our day. We expect this will be interesting, enlightening and entertaining.
Cooper Lees - Facebook
Cooper Lees
Representing Facebook we’ve got Cooper Lees providing an insight into the numerous open source projects they leverage every day, how they are working upstream, and innovations like the Open Compute Projects and FBOSS (their linux switch/router project).
Cooper is a Production Engineer in the Network PE team at Facebook in Menlo Park, CA, originally hailing from Wollongong, NSW, Australia. Network PE help the ‘true’ Network Engineers automate the network, not re-invent the wheel and take on existing Facebook technologies that solve their problem. Outside of being a nerd, Cooper enjoys playing Cricket, AFL (yes, in the Bay area) and Snowboarding in Tahoe as much as possible.
Carol Smith - Google
Carol Smith
Google Summer of code is now 10 years old, and Carol Smith from Google will be provide an update on the project and how this is benefiting the open source community in our part of the world.
Carol Smith is an Open Source Programs Manager at Google. She has managed the Google Summer of Code program for 5 years. She has a degree in Journalism from California State University, Northridge.
Mark McLoughlin - Red Hat
Mark McLoughlin
Then from Red Hat we’ve Mark McLoughlin with some insight on some of the innovation we should see in 2015. Mark will give a whirlwind tour of recent technology shifts - covering everything from virtualization, containers, IaaS, PaaS, SDN, scale-out storage, Big Data, DevOps and more - and how they are all coming together to form the basis of today's agile data center.
Mark McLoughlin is a consulting engineer at Red Hat and has spent over a decade contributing to and leading open source projects like GNOME, Fedora, KVM, qemu, libvirt, oVirt and, of course, OpenStack. Mark is a member of OpenStack’s technical committee and the OpenStack Foundation board of directors. He contributes mostly to Oslo, Nova and TripleO but will happily dive in to any project.
recording release: yes license: CC BY-SA
Location
--------
John Hood Plaza
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/