pre-release: La 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: La at Caro Mon January 16, 9:30p


La
=========================
When: 9:30 AM Monday January 16, 2012
Where: Caro

None

Topics
------
1. Conference Opening


(Needs description.) 
 recording release: yes license: CC BY-SA  

2. Haecksen by Lana Brindley


(Needs description.) 
 recording release: yes license: CC BY-SA  

3. Multimedia and Music Miniconf by Jonathan Woithe


(Needs description.) 
 recording release: yes license: CC BY-SA  

4. Open Programming Miniconf by Christopher Neugebauer


(Needs description.) 
 recording release: yes license: CC BY-SA  

5. Sysadmin Miniconf by Simon Lyall


(Needs description.) 
 recording release: yes license: CC BY-SA  

6. Arduino Miniconf by Jon Oxer and Andy Gelme


(Needs description.) 
 recording release: yes license: CC BY-SA  

7. High Availability and Distributed Storage by Tim Serong


(Needs description.) 
 recording release: yes license: CC BY-SA  

8. Business of Open Source Miniconf by Martin Michlmayr


(Needs description.) 
 recording release: yes license: CC BY-SA  

9. Browser Miniconf by Shane Stephens and Cameron McCormack


(Needs description.) 
 recording release: yes license: CC BY-SA  

10. High Availability and Distributed Storage by Tim Serong


(Needs description.) 
 recording release: yes license: CC BY-SA  

11. Browser Miniconf by Shane Stephens and Cameron McCormack


(Needs description.) 
 recording release: yes license: CC BY-SA  

12. Business of Open Source Miniconf by Martin Michlmayr


(Needs description.) 
 recording release: yes license: CC BY-SA  

13. Sysadmin Miniconf by Simon Lyall


(Needs description.) 
 recording release: yes license: CC BY-SA  

14. Open Programming Miniconf by Christopher Neugebauer


(Needs description.) 
 recording release: yes license: CC BY-SA  

15. Arduino Miniconf by Jon Oxer and Andy Gelme


(Needs description.) 
 recording release: yes license: CC BY-SA  

16. Multimedia and Music Miniconf by Jonathan Woithe


(Needs description.) 
 recording release: yes license: CC BY-SA  

17. Haecksen by Lana Brindley


(Needs description.) 
 recording release: yes license: CC BY-SA  

18. Haecksen by Lana Brindley


(Needs description.) 
 recording release: yes license: CC BY-SA  

19. Business of Open Source Miniconf by Martin Michlmayr


(Needs description.) 
 recording release: yes license: CC BY-SA  

20. Open Programming Miniconf by Christopher Neugebauer


(Needs description.) 
 recording release: yes license: CC BY-SA  

21. Arduino Miniconf by Jon Oxer and Andy Gelme


(Needs description.) 
 recording release: yes license: CC BY-SA  

22. High Availability and Distributed Storage by Tim Serong


(Needs description.) 
 recording release: yes license: CC BY-SA  

23. Sysadmin Miniconf by Simon Lyall


(Needs description.) 
 recording release: yes license: CC BY-SA  

24. Multimedia and Music Miniconf by Jonathan Woithe


(Needs description.) 
 recording release: yes license: CC BY-SA  

25. Browser Miniconf by Shane Stephens and Cameron McCormack


(Needs description.) 
 recording release: yes license: CC BY-SA  

26. Speakers' Briefing Session - meet at Caro Founders' Theatre


(Needs description.) 
 recording release: yes license: CC BY-SA  

27. Keynote - Bruce Perens


(Needs description.) 
 recording release: yes license: CC BY-SA  

28. Optimizing Web Performance with TBB
Nicolas Erdody,Lenz Gschwendtner

Threading Building Blocks (TBB) is a C++ threading library that makes multicore programming more accessible. We considered TBB for web application developers working in script languages.

Many websites require a non-trivial amount of per-request processing in the application layer, to retrieve, consolidate or manipulate data. Achieving better performance at this level improves response times and the overall user experience. Parallelising access to database and web service back-end layers can yield substantial improvements in perceived performance.

We added TBB support into PHP and Perl, starting with HipHop as the PHP implementation of choice and later adding Perl support.

HipHop is a PHP to C++ cross compiler that was developed by Facebook to cut down on resource needs and speed up the execution times of their gigantic web infrastructure. HipHop project is a PHP implementation thread safe and already uses TBB for memory management. 

We started by extending the existing support and added first only the new *parallel_for* function. Later, we added concurrent data structures and re-implemented our first approach. We have now a robust implementation of *parallel_for* and *parallel_reduce* with the data structures needed to support them. 

In our work with the PHP HipHop compiler we also wrote a patch set for WordPress and enhanced WordPress with our new *parallel_for* language extension. This trial brought us instant success in reduced page load times. The patch set for WordPress only replaced some key *foreach* loops with *parallel_for* and was our first real success with the TBB library in PHP. 

The Perl project worked towards a Perl module that can be used to get access to TBB functions directly. The module is now stable enough to demonstrate the gain by using TBB in Perl. Demos of our work are running on geopic.me

Threading interpreters bury they own set of challenges but we can get further by using TBB. The libraries we produced so far will be further developed and maintained. We will continue working on both platforms to expose the power of multicore CPUs to developers in an approachable way. 
 recording release: yes license: CC BY-SA  

29. Smashing a square peg into a round hole: Automagically building and configuring Linux systems that are wildly different.
David Basden,Christopher Collins

Smashing a square peg into a round hole: Automagically building and configuring Linux systems that are wildly different.

David Basden and Chris Collins

Abstract

You can’t walk two metres down the street without someone going on about how cool and hip The Cloud is these days, being able to spin up hundreds of identical Linux VMs easily. Even if you’re running your own cloud hardware, tools to build and configure lots of identical systems or VMs are a dime a dozen.  But what if you every system you build is actually totally different?  What if there is no “standard build” or even anything close, with different hardware, networking, software, distro, services, firewalls etc. every time, but you don’t want to spend all your time doing custom server builds and configuration?

Working for a hosting provider, we have it even worse that that: Not only do most of our server builds have custom requirements, we also have to configure lots of our own individual systems to deal with monitoring, customer notifications, backups, fire-walling, accounting and system updates. Building a system and configuring the systems that support it by hand can take the best part of a day.

Using some really cool algorithms, we’ve made some software that will take vague hand-waving from sales people and turn it into a deterministic set of build steps that can be automated, without a sysadmin being involved at all.  We’ve also written some software that can hook-up scripts, modules and APIs between different servers securely with almost no overhead,  and have it controllable from a single, trivial asynchronous API connection. Between the two of these we’ve gotten heterogeneous server builds that are fully automated, in minutes. The two bits are “make magic” and Orchestra.
Rather than spinning up yet another bland VM copy, you get a beautiful and unique snowflake of Awesome.

make magic

The core of “make magic” derives the tasks required to build a system based on high level requirements. It takes a large pre-defined directed, acyclic dependency graph, and prunes it based on predicates generated from the high level requirements. The graph is then traversed to yield a list of tasks that can then be automated, with the traversal maintaining that any given task has already had it’s dependencies satisfied.  It can be guaranteed to always output a valid, correct list of tasks for any set of input requirements.

Once all this is done, “make magic” also keeps track of whether each task has been completed, or has failed etc, with a simple state machine.

David is going to talk about some the really interesting underlying problems that  come up when you have to automatically generate a really specific, and provably correct set of steps from hundreds of thousands of permutations based on some high level requirements. He’s then going to show how you can do this yourself with things you probably have lying around the home, as long as your home has a Linux box, and a network connection to download some python.

make magic is written in pure python, but the talk should be accessible to people that don’t know it. Graph theory may be mentioned ‘cause it’s totally cool, but not in a way that is going to get in the way of people who have never heard of it.

Orchestra

Orchestra, the system to remotely execute all of the tasks that need to be automated, uses a very lightweight message-passing API over SSL. It can take a task and run it on either a single host, all of a set of hosts, or one host out of a pool. Unlike using ssh for remote control, Orchestra is asynchronous, and so lightweight that it can easily handle hundreds or thousands of concurrent jobs.  It detects and propagates job failures, and deals gracefully with loss/reboots of servers it’s running jobs on.  It’s packaged up for Debian and Redhat, with a core written in Go, and libraries/clients for shell, Python, Go  (or pretty much anything else that can talk to a socket)

Chris is going to talk about Orchestra, and show out how amazingly cool and simple it is, while it can at the same time be used to do really powerful things (generally all at the same time).

Shut up and give me the code

“make magic” is available at https://github.com/anchor/make-magic
Orchestra is available at https://github.com/anchor/Orchestra

Bio

Chris and David both work for Anchor Systems in Sydney as Linux Sysadmins that spend way too much time doing development to code themselves out of a job.

Chris designed and wrote Orchestra, which Anchor are letting him open source. David did much of the design and implementation of the original build algorithm magic. He then wrote the much cooler free software version “make magic”, which Anchor are also letting him release. 

David has been a Linux sysadmin for over 15 years, and has spend a large chunk of that time trying to figure out how to get hundreds of servers to be their own unique snowflakes while also not having to do stuff by hand.   He will talk enthusiastically about what he thinks are the interesting parts of systems / algorithms / concepts  that interest him, in the hope that people listening will find them interesting too.

For as long as Chris can remember, he’s been fascinated by Computers.  It was hardly a surprise to family and friends when he became a UNIX Systems Administrator early in his career.  That was 12 years ago, and he hasn’t stopped yet.  Since then he’s also been a developer on Linux based appliances, deployed computational clusters and reverse engineered USB devices.

Target audience: sys admins
 recording release: yes license: CC BY-SA  

30. The Kernel Report
Jonathan Corbet

This talk will be a fast-paced tour of what has been happening in the kernel community in the last year, and what can be expected in the year (or so) to come.  Attendees of any technical ability will go away with a better understanding of what's up with one of the largest and most active software development projects on the planet.
 recording release: yes license: CC BY-SA  

31. The best Software Freedom Day in the world - and how you can do it too!
Kathy Reid

The Software Freedom Day event in Melbourne, 2010, was judged to be one of the three best Software Freedom Day events in the world [1]. 

Lead by Dale Dickens, and with massive contributions from Donna Benjamin, Ben Sturmfels and countless others, the event attracted over $6000 in sponsorship, hundreds of visitors, featured a federal Senator as a keynote speaker and pulled together disparate user groups.

Unfortunately Kathy was diagnosed with breast cancer a month after Software Freedom Day 2010 [2]. While undergoing chemo, she began planning BarCampGeelong, which was held in July 2011. Again, it was heralded a success.

Fairy dust and magic sprinkles were not the secret ingredients here; good planning, project management, stubbornness, determination, people skills and attention to detail *were*. High doses of dexamethasone steroids may have also played a small role [3].

This session will impart the skills required to replicate the enviable outcomes seen from Software Freedom Day and BarCampGeelong, and give other FOSS advocates the confidence and capabilities to run engaging, successful community events. 

If you've ever thought about running a BarCamp, WordCamp, PyCon, Software Freedom Day, or even LCA in your home town, this presentation is for you!

The key takeaways will be;

VISION - Understanding what you're trying to achieve

MEASUREMENT OF OUTCOMES - What statistics or metrics will tell you whether you've achieved your objectives?

VENUE AND FACILITIES - What to look for in a suitable venue - and what you should really be paying for it. 

FINANCIALS AND FUNDING - Understanding cost components of the event, and sources of funding. Government sources, filling in grant applications, budgets etc will be covered. Examples will be happily provided.

A WINNING TEAM - How to find people willing to help, and understanding their skillset, level of commitment and capacity. Also covered will be strategies to help prevent burnout, and ensure you have a team to run the next event.

MARKETING, PROMOTION and PUBLICITY - How to get the word of your event out there. This section will cover media releases, user group mailing, social media and other avenues.

RISK MANAGEMENT - Managing and planning your way out of trouble and collecting information to manage risks for future event iterations.

SPEAKERS and PRESENTATIONS - Where to find good speakers and how to assess engaging and compelling presentations. Also covered will be what to do when a presentation or a speaker is going off track. 

EVENT REGISTRATION - What works and what doesn't

CATERING AND FOOD - Is it necessary and what should you look for?

FOLLOW UP - Why it's so important to help build community, recognise participation and build assets such as photograhs and blog posts that help your case in the future. 







1. http://softwarefreedomday.org/en/competition/winners-2010
2. Software Freedom Day DOES NOT cause cancer :-)
3. Joke. You don't need steroids to run a BarCamp. But they do help with chemo. 



 recording release: yes license: CC BY-SA  

32. Creating the Open Source Academy
Ian Beardslee

The Catalyst Open Source Academy is an initiative designed to provide training and work experience for young New Zealand technologists.

The pilot programme was held for two weeks in January 2011.  It gave 17 Secondary School students a taste of real open source development through a combination of classroom sessions and hands-on project work.

The aim was to get the students to the point where they could usefully contribute to a real (open source) project.

By organising and funding the Academy, Catalyst hoped to show young technologists how to participate in open source communities and to fully explore their passion for IT through freely available open source tools.

In this presentation Catalyst's Ian Beardslee will outline how they put the initiative together, what worked and what didn't, and lessons learnt from the project.
 recording release: yes license: CC BY-SA  

33. scaling web applications with message queues
Lenz Gschwendtner

Message driven development can be hard due to the asynchronous nature
of messaging. Messaging is also often still considered enterprisy
stuff and therefor out of reach for the average developer. I'll show you
how to rewrite a monolithic web application into a scalable web app that
uses RabbitMQ as the message queue. In the second step we introduce
Redis as a caching layer and I will show you how to make a dog slow web
app into a light wight and easy to maintain and scale app stack.

Even though this talk will be mainly about AMQP based messaging I will
briefly talk about ZeroMQ and (if time permits and interest arises)
about the workflow engine I wrote on top of CouchDB and RabbitMQ. 

Even though I work mainly with Perl I successfully applied this method
to other environments even as exotic as PHP based websites running Java
backends. This talk is intended for a technical audience that is
interested in web application development and scaling of web apps. It is
also interesting for anyone who is interested in messaging and message
driven development.
 recording release: yes license: CC BY-SA  

34. Extracting metrics from logs for realtime trending and alerting
Jamie Wilkinson

Application logs contain a wealth of data on events in a system, but are typically only examined after an incident occurs.  Due to a lack of a common language between open source tools, these events remain hidden, unexported to a monitoring system.

In this presentation, Jamie will describe and demonstrate a general purpose tool for extracting metrics from logs, and exporting them in real time.
 recording release: yes license: CC BY-SA  

35. EFI and Linux: the future is here, and it's awful
Matthew Garrett

The PC BIOS is a dreadful thing. Poorly standardised and often poorly implemented, it has one job to do and frequently does it badly. The kernel and bootloaders are obliged to devote extensive sections of code to working around issues present in the BIOS, code and time that could have been better spent elsewhere.

Everyone agrees that the PC BIOS is awful. So why, when Intel introduced the Extensible Firmware Interface (EFI) as a replacement for it, did we not great it with open arms?

This presentation will introduce EFI to the audience, covering the reasons for its existence and its benefits. It will then go on to discuss everything that's wrong with it, from poorly considered aspects of the specification to implementation flaws.

Should it be necessary, audience members are advised to provide their own gin.
 recording release: yes license: CC BY-SA  

36. Mistakes were made
Selena Deckelmann

In an ideal world, code would have complete test coverage, releases would be seamless and databases wouldn’t require downtimes to upgrade. The fact is, most companies still have to manage systems upgrades and code deployment that includes downtime. This talk is for you.

Maintenance windows are rarely wanted, but frequently needed. And sometimes things go horribly wrong.

This talk will teach you how to plan for the worst, minimize risk and recover gracefully from failure.

Elements to successful downtimes include: proper testing, automated checks for success, and complete rollback plans, and a timeline. We’ll go over useful tools for keeping track of what is going on before, during and after a downtime, and talk through good and bad communication for employees and customers.

We’ll also talk about how non-technical people can evaluate technical change. And how having the right stakeholders involved from the beginning of the planning process reduces risk.

Stories to illustrate success and failure will come from Selena Deckelmann’s 15 years in education, public and private sectors, as a consultant, DBA and IT manager.  Additional examples 
 recording release: yes license: CC BY-SA  

37. antiSMASH: Searching for New Antibiotics Using Open Source Tools
Kai Blin

Ever since Alexander Fleming discovered the first antibiotic being produced by a Penicillium mould in 1928, scientists have been searching bacteria and fungi for new substances to combat infectious diseases. In the last 40 years however, only few new substances have been discovered that actually reached the market. In the arms race between bacteria developing new resistances and humanity developing new antibiotics, a more organized approach on drug discovery can keep us from falling behind. With the advent of high throughput genetic sequencing, a large number of bacterial genome sequences have become available for analysis. Rather than testing every candidate strain for antimicrobial activity and then painstakingly isolating and characterizing the substance causing this activity, it has now become viable to predict the substances a bacterium can produce using computer-based prediction algorithms.

antiSMASH is an Open Source pipeline that combines all published methods for predicting the genetic potential to synthesize antibiotics and other interesting small-molecular substances in bacteria and fungi. By combining existing Open Source tools with re-implementations of published but proprietary prediction methods, antiSMASH manages to provide life scientists with a user-friendly web interface and publication-quality illustrations.

This talk will present to the interested non-biologist how the whole process of going from sequence information to prediction of produced antibiotics is done, requiring as little previous knowledge in mathematics and biology as possible. The author will also talk about the differences in developing Open Source software in an academic environment as compared to traditional OSS development.
 recording release: yes license: CC BY-SA  

38. Low-hanging Fruit vs. Micro-optimization, Creative Techniques for Loading Web Pages Faster
Trevor Parscal

Optimizing web pages has historically been focused on what's happening on the server, and more recently how resources being sent to the client are compressed and cached. Some have even resorted to clever JavaScript packing maneuvers, extreme image spriting and even micro-optimization of CSS selectors. Unfortunately nearly all of these performance improvements come at the cost of reducing development efficiency, and yield only minor gains. Puling from practical experience implementing and deploying a variety of features for Wikipedia, Trevor and Roan applied creative ideas to fundamental problems and came up with a set of techniques that have proven themselves to significantly improve performance.
 recording release: yes license: CC BY-SA  

39. This Old Code, or Renovating Dusty Old Open Source For Fun and Profit
Greg Banks

Software is a human construct and like everything we make it 
eventually falls into disrepair.  Houses get mould, vermin
infestations, and frightening old wiring.  Software projects get
equivalents of these, albeit a few decades faster.

This talk is about the experience of doing a major renovation on 
a software relic: the Cyrus IMAP server.  Fastmail (now Opera
Software Australia) has been using Cyrus commercially to provide
an IMAP interface to an email store for years now, and over the 
last year has significantly contributed to a resurgent effort to
modernise the code and rejuvenate the community.  The author
works fulltime on this project and has both observed and
contributed.

Topics will include: introducing modern software engineering 
practices like Continuous Integration, making testing happen,
attracting a developer community, a practical guide on how to
find and fix outdated coding practices (a.k.a. bugs waiting to
happen), and an introduction to paleoentomology.  All
illustrated with real world examples.

If your organisation depends on ancient software in need of 
revitalising, or if you're just looking for some spare time Open 
Source work to keep your hand in, come to this talk and get some
practical tips and a laugh or two.

 recording release: yes license: CC BY-SA  

40. Tux in Space: High altitude ballooning
Joel Stanley,Mark Jessop

Tux in (near) space!

This talk will describe how to launch and recover high altitude balloons: logistics, regulations, and most importantly the open source hardware and software used. Arduino hackers, amateur radio operators and anyone who likes seeing photos of earth from 35km will enjoy this talk.

Project Horus is a high altitude balloon project run by amateur radio and electronics enthusiasts for fun and experimentation. We launch payloads into the stratosphere, capturing photographs, recording sensor data and provides a launch platform for high altitude experiments.

Attendees of  LCA 2011 will be familiar with the project; the team showed off the video of a plush Tux, and auctioned a print of that toy at the conference dinner.
 recording release: yes license: CC BY-SA  

41. Erlang in production: "I wish I'd known that when I started"
Bernard Duggan

Erlang is gaining popularity as a language for developing robust, maintainable, concurrent systems for high load environments. Its list of features, including hot code loading, crash isolation and easy concurrency make it look extremely attractive, but any even moderately experienced developer knows there's no silver bullet.

In this talk we discuss our journey from being "Erlang newbies" to pushing a critical system out into M5's high-load production telephony environment. We will focus in particular on the various "lessons learned" from the experience; notably:

* Several great ways to crash the VM and bring down your whole system

Having your entire system in a VM can lead to a false sense of security. Things can go wrong, and when they do it will really hurt. We look at ways to break the VM and how to avoid them.

* Message queues – you really need to look after them

Message queues lie at the heart of Erlang's concurrency system, and for 99% of cases they fall into the "you don't have to care about the internals, they just work" category. We discuss how to avoid your system hitting the 1% of cases where they can cause serious pain.

* Running Erlang as a Unix-style service

One oft-overlooked shortcoming of Erlang is its lack of ability to be easily started up with a service (/etc/init.d) style interface. We take a brief look at erld, our in-house solution to the problem. [Note: We are presently awaiting management approval to release erld as open source – we hope to have this in the next couple of months, well before LCA rolls around].

* Hot code loading – it's not nearly as easy as it said on the brochure

Hot code loading promises little short of 100% uptime. We talk about how trying to get it working panned out in practice and how to maximise your chances of getting it to work in your system.

* Monitor your system like a hawk

Erlang makes it easy for problems to go un-noticed for quite a while before they suddenly cause serious damage. We look at some key areas you can monitor and how to do so.

This talk is meant to be anything but a "why Erlang sucks" talk; we still love Erlang and are pushing forward with moving all our core systems to use it. We now, however, have a much better understanding of its limitations and foibles than when we started out and we hope to help others avoid some of the pitfalls we have encountered.
 recording release: yes license: CC BY-SA  

42. IPv6 Dynamic Reverse Mapping - the magic, misery and mayhem
Robert Mibus

We all want IPv6, because the sky is falling, and many of us have gone back to the future and are trialling IPv6 already.  This is a good thing.  But many of us want our NodePonies too - we want those v6 addresses reverse mapped.  There's no way your ISP is going to handle all those reverse mappings manually like they did for v4 - there's around  2^72 entries per customer!  What do you use to solve your problem - use pymds!

This presentation is a real-world case study of how a successful Australian ISP - Internode - took a simple open-source DNS server and made it part of their production DNS environment.  As we fall down the rabbit hole we'll discuss:

* Why people want all IPv6 addresses to have reverse mappings
* Solutions that were ruled out (eg. BIND's "GENERATE" macro)
* Why pymds was picked (ie., rapid prototyping is better than weeks of effort).
* Naming/formatting options we went through for what the reverses should look like
* Options for integrating it into our main DNS zones.
* How can we easily override the automatic generation, without complicating the codebase.
* Pitfalls we expect to see
* Future evolution possibilities, competing projects

[Note: Our modifications to pymds are not yet available publicly, but will be by the conference - promise!  We know that's not ideal, but our legion of code ponies are busily cleaning up the source before releasing - internal approval to release has already been granted]

Appropriate for Sysadmins, advanced users, and people playing with IPv6 in their basement.
 recording release: yes license: CC BY-SA  

43. Scaling OpenStack Development with git, Gerrit and Jenkins
Monty Taylor,James Blair

The OpenStack Project has seen a phenomenal growth in its first year and a half. Part of the reason that we've been able to handle the dramatic influx in developers is by having automation systems that allow us to treat all developers equally from a process perspective, keep our trunk always clean by performing testing pre-merge and still be streamlined enough that the process did not get in the way of development.

James Blair and I will start with a brief (very brief) history of where we started and the techniques we employed at first, including bzr, launchpad and tarmac. We had some wins and learned some excellent lessons from the early setup.

We'll move quickly on to the meat though, which is the design and implementation of the current system, based around a combination of gerrit and jenkins. We'll cover the workflow that we support and require, how we implemented it and what the challenges were.

At the end of the talk, you should come away with a good sense of why we made the choices we made and how they might be applicable to your project, and how to go about implementing them. You should also have been convinced that any process which does not employ pre-merge testing is doomed to failure. :)
 recording release: yes license: CC BY-SA  

44. Codec 2 - Open Source Speech Coding at 2400 bit/s and Below
David Rowe

Codec2 is an open source low bit rate speech codec designed for communications quality speech at around 2400 bit/s. Applications include low bandwidth HF/VHF digital radio and VOIP trunking. Codec 2 operating at 2000 bit/s can send 32 phone calls using the bandwidth required for one 64 kbit/s uncompressed phone call. It fills a gap in open source, free-as-in-speech voice codecs beneath 5000 bit/s and is released under the GNU Lesser General Public License (LGPL).

Speex and the other open video and audio codecs have proven it’s possible to create a patent free, high quality codec. There is an important social theme behind these technical projects. A free codec helps a large amount of people and promotes development and innovation. A closed codec helps a small number people make money at the expense of stifled business and technical development for the majority.

One important part of Codec 2 is the use of open source and community development techniques. The net result was access to a world wide "brains trust" and network of beta testers that has resulted in swift development of effective DSP algorithms.

This presentation will explain the advanced DSP techniques used in Codec 2 in terms the average Linux user can understand, plus give examples of end user applications.
 recording release: yes license: CC BY-SA  

45. Operating System Support for the Heterogeneous OMAP4430: A Tale of Two Micros
Etienne Le Sueur

The OMAP4430 is a system-on-chip recently released by Texas Instruments. What makes it interesting, is that not only is it the first dual-core ARM Cortex A9 embedded ARM processor, but TI also put two Cortex M3 micro-controllers on the same chip, sharing the same memory. All four cores support the ARM Thumb-2 instruction set, so conceivably, they could all run SMP Linux!

This talk will outline all of the hurdles that we encountered, hacks we did to get around them, and also present some performance numbers for the system. We also hope that manufacturers can take something from our experience making future asymmetric chips more amenable to running Linux without all the hacks!
 recording release: yes license: CC BY-SA  

46. POLICY CIRCLES - Freedom to Think Aloud
Dan McGarry

Despite its immensity, the Pacific can feel like a tiny place, fraught
with small-town, identity-driven politics. Isolated and outnumbered by
consultants, advisors and family- or island-based alliances,
decision-makers often acquiesce to ideas they might not share.

Policy Circles aims to change that. We're building a distributable
social networking app that emphasises frank, confidential discussion
which in turn feeds public debate. Users can take on a single,
persistent online persona to present their honest views without
compromising their real life identity.

With curated information streams supplemented by user-submitted content,
we'll supply Pacific decision-makers with appropriate, useful research
and opinion, feeding open, honest discussion, free from undue pressure
from inside and out.

Policy Circles aims to fill that gap by offering a platform that is open to those dealing with policy development in the islands but also holds a public section that publishes profiles about the participating countries, the organizations and the various people involved in policy development.

Policy Circles is built on top of CouchDB and Mojolicious and was bootstrapped in Vanuatu in October 2011. It is driven by the Pacific Institute for Public Policy in Port Vila and we try to reach participation of all pacific islands by 2012. The project is unique in the way it tries to address both, the need for public discussion and the need to protect privacy in these discussions.
 recording release: yes license: CC BY-SA  

47. Moving Day: Migrating Big Data from A to B
Laura Thomson,Shyam Mani,Justin Dow

In January 2011 we moved the Mozilla crash reporting system from old creaky hardware in San Jose to a new shiny datacenter in Phoenix. This system contains more than 40TB of data in HBase, the Hadoop database, and PostgreSQL. The data collecting app has a requirement for close to 100% uptime. On top of that we have data processing, an API, and a webapp. After many months of work, the migration went seamlessly.

In this session we’ll talk about:

- The checklist manifesto, reprised, and understanding the critical path

- How to move all that data in a reasonable timeframe

- The importance of devops culture in success

- Automating packaging and configuration and how it will save you
  
- Understanding the difference between old and new platforms: correctness testing, load testing, and smoke testing

Attendees should walk away with an outline of everything they’ll need to do to achieve a successful data center migration.

 recording release: yes license: CC BY-SA  

48. Opus, the Swiss Army Knife of Audio Codecs
Jean-Marc Valin

Ever thought that there were too many audio codecs, each with its own special niche? So did we, so we made a new one (1). The difference is that Opus scales from very low bit-rate VoIP to high-fidelity, low delay music transmission. It can be used for anything from making phone calls, to remote jam sessions, to archiving your music collection. It's better at speech than Speex, and better at music than Vorbis and MP3.

Opus is the product of a standardization process at the IETF, as a collaboration between the developers of the Xiph.Org CELT codec (2) and Skype SILK codec. This talk will describe the features, as well as a technical overview of the codec. It will also give an overview of the standardization process, including the issues involved in standardizing a free codec at the IETF. At last,  listening test results will be presented, along with a demo.

(1) http://xkcd.com/927/
(2) Presented at LCA 2009
 recording release: yes license: CC BY-SA  

49. Efficient multithreading with Qt
Dario Freddi

Multithreaded appliances are becoming a standard each developer must know at his best. Qt, one of the most popular Open Source frameworks, powering projects such as MeeGo and KDE, is also among one of the most popular libraries providing multi-thread facilities.

Lots of developers are already taking advantage of Qt and his multi-threading facilities, but most of the times, they are not familiar with the least known features, which could greatly improve their work. Are you creating a separate thread for processing a single method? Are you processing a list of elements in a single thread, or just in a separate one? Uploading textures to OpenGL from the main thread? Or worse, disregarding threads at all? This talk is for you.

Besides showing the usage of the most common features, such as QThread, QMutex or QSemaphore, this talk will strongly focus on uncommon features such as QtConcurrent or the new threaded OpenGL support, which are what makes Qt really taking a stand, and can ease your life as a developer while improving performance.

A variety of demos for each topic will be shown, to see how each component can fit into a real-world appliance.
 recording release: yes license: CC BY-SA  

50. Multi-tenancy, multi-master, Sharding, scaling and analytics with Drizzle
Stewart Smith

The Drizzle database had its first stable GA release at the start of 2011. Since then we have been working on a few features taht directly relate to be able to easily produce applications that can scale.

1) True mulitenancy.
  running a database server in a Virtual Machine is an instant way to kill performance. A VM running a database server for each user doesn't scale.
  Drizzle now has a concept of CATALOGs, this can give each tenant their own namespace for databases, tables and users.

2) Multi-master
  Drizzle has the ability to replicate from multiple masters, enabling you to pull all your shards into one database for analytics and cross-shard queries.

3) Sharding
  The Drizzle client library (libdrizzle - which can speak the MySQL protocol to Drizzle and MySQL servers) has new features to help with sharding, being able to connect to a shard, a read-only replica of a shard as well as supporting moving shards between machines and adding more capacity.
 recording release: yes license: CC BY-SA  

51. where is your data cached and where should it be cached
sarah Novotny

Taking a look at the many layers of caching in the modern webstack can lead to some interesting optimizations. We know that raid card caches, disk caches and CPU caches all exist at the hardware level, but how do they interact with database caching, application code caching and rendered page caching. Where are the redundancies and where is the most optimal location for your services to cache? Are you risking data integrity by using both disk and raid card caching? Is there a similar risk in using both filesystem and database caching? These are hard won lessons if you have to learn them during an outage. they can be avoided with some forethought and benchmarking. I’ll call out the many layers where data is cached and talk about some of the risks and potential performance gains that we’ve found by selectively disabling and adding particular caching layers.
 recording release: yes license: CC BY-SA  

52. Keynote - Paul Fenwick


(Needs description.) 
 recording release: yes license: CC BY-SA  

53. I Can't Believe This is Butter! A tour of btrfs.
Avi Miller

Btrfs ("Butter FS") is a new copy on write filesystem for Linux aimed at implementing advanced features while focusing on fault tolerance, repair and easy administration. Initially developed by Oracle, Btrfs is licensed under the GPL and open for contribution from anyone.

This tutorial will take users through some of the new features of the btrfs file system, including:

- Creating/mounting the filesystem
- Setting up mirroring/striping
- Adding/removing devices
- Rebalancing data
- Growing/shrinking volumes
- Creating snapshots/subvolumes
- Booting from snapshots

On completion, attendees should be confident about using btrfs in their own environments and taking advantage of some of the new features.
 recording release: yes license: CC BY-SA  

54. Beginning with the Shell
Peter Chubb

The Bourne shell is universally available on every Linux system, from the least-powerful embedded device, to the largest supercomputer.
In this tutorial, we'll cover the basics of:
 The Shell's input: how it reads words, splits them, expands special stuff, etc.
 Control flow: case, if, while, for
 Common utilities: sed, awk, grep, test, find, xargs, etc

After some introductory material, we'll spend the time working together to build a simple server for fortunes/fables entirely in shell. 

Attendees should bring laptops, and be competent with a text editor.
 recording release: yes license: CC BY-SA  

55. Developing accessible web applications - how hard can it be?
Silvia Pfeiffer,Alice Boxhall

Presentation by Silvia Pfeiffer and Alice Boxhall

This talk will introduce some of the background any developer creating a web application should have when considering accessibility.

There are many simple, but important things that we can do when developing Web applications that will have a massive impact on their accessibility. At the same time, they help us make our Web pages more navigable and usable.

The same techniques which will make a banking application easier to use for a blind user will also benefit someone accessing the site using a mobile phone or tablet PC. An email application with keyboard shortcuts will be more usable for both motor impaired users, and power users who prefer to avoid switching to the mouse. Multimedia applications with captions may be used by people who are deaf or simply situationally unable to play audio.

We will cover:
* The tools and techniques people with visual impairments use to interact with, navigate through and consume web pages on different platforms
* Some key techniques to improve the accessibility of rich, Javascript-heavy web applications, including tools to assist in accessibility testing
* The systems that take a snippet of HTML from the Web page through the browser accessibility APIs to screen readers and braille devices
The latest accessibility-related developments in HTML5, in particular around multimedia elements.


We’ll also take an example of an existing Web application and show some key approaches to make it accessible.

Key technologies covered: ORCA, NVDA, JAWS, VoiceOver, ChromeVox, ChromeShades, WAI-ARIA, accessible forms, captions, audio descriptions, IAccessible2, UIAutomation, ATK/AT-API, NSAccessible, MSAA


Alice is part of the Google Chrome development team focusing on implementing accessibility support in the browser. Silvia is active in the HTML5 Working Groups for audio and video accessibility and is helping YouTube become more accessible.
 recording release: yes license: CC BY-SA  

56. OGPC - One Geek Per Classroom
Thomas Sprinkmeier

The thrilling adventures of a geek volunteering at his kids' schools to promote geek-dom.

For the last 3 terms I've been running a weekly session in all things geek, from Guido van Robot programming to Lego Mindstorm, circuit-glue to cyber-safety, rocketry to metallurgy.

My motivation is to inspire curiosity, the burning desire to know how things work (and how to make them work better), in short: geek-dom.

My talk is about how to do this in a minimal budget using not much more than remastered Linux DVDs, salt and LEDs.

The title is my challenge to the community: find yourself a classroom and spread the word!
 recording release: yes license: CC BY-SA  

57. The Web as an Application Development Platform
Shane Stephens,Mike Lawther

This talk will discuss the current state of the World Wide Web as a platform for the development and deployment of applications, providing answers to the following questions:
* How does web application development differ from the development of traditional desktop applications? 
* How easy is it to shift from one environment to the other?
* What pieces are missing from the web in this regard?
* What does the web provide that desktop application environments do not?
* is it possible for an application to be deployed in both environments simultaneously?

Attendees will take away:
* an understanding of the fundamental components of the state-of-the-art of the web platform.
* when it makes sense to consider writing a web app instead of a desktop app.
* pointers to the basic technologies required to make rich, desktop-like web applications.
 recording release: yes license: CC BY-SA  

58. XFS: Recent and Future Adventures in Filesystem Scalability
Dave Chinner

Filesystems are being asked to scale to larger configurations every week. They need to store more files, larger amounts of data and be able to index that data more efficiently than ever. XFS has had a number of pain points for managing large numbers of files and complex metadata structures that limit it's ability to scale out to the capabilities of it's underlying structures. 
                                                                                 
The first part of this presentation describes the underlying reasons for these limitations and how they have been solved over the past 18 months. Through the use of pretty graphs, shiny pictures and puppies, it will be demonstrated that the work of the past 18 months has resulted in XFS having the most scalable and highest performing metadata subsystem of the current crop of Linux filesystems.  
                                                                                 
The second part of this presentation will address the challenges we are facing over the next 18 months. These challenges are focused around reliability and robustness and having confidence in a filesystem indexing petabytes of storage.  
                                                                                 
The problems being solved will be described, along with the solutions being designed, prototyped and implemented that will allow robust deployments of petabyte scale XFS filesystems. Topics being discussed involve improving error detection and handling, use of metadata CRC codes, reverse mappings for efficient lost object recovery and more. More details of some of these topics can be found here:                                                               
                                                                                 
http://xfs.org/index.php/Reliable_Detection_and_Repair_of_Metadata_Corruption    
                                                                                 
In the course of the presentation, it will become obvious why ext4 will not catch up to or replace XFS and why btrfs complements rather than competes with XFS. In other words, the presentation will show that XFS is still the filesystem of choice for large scale storage deployments on Linux and will continue to be so for the indefinite future.

The presentation is moderately technical, but most users and administrators of XFS should have no trouble understanding the content. There is, however, sufficient technical depth in the presentation that developers should still find it interesting.
 recording release: yes license: CC BY-SA  

59. TBA


(Needs description.) 
 recording release: yes license: CC BY-SA  

60. Design your own Printed Circuit Board using FOSS
Scott Finneran

This is a near two hour course on how to design a Printed Circuit Board (PCB) from scratch using only Free and Open Source Software. The student will learn skills such as how to design and layout a board that will work the first time (without bursting into flame). They'll learn how to minimise the manufacturing cost of their new board and how to navigate the maze of manufacturing options. 

At the same time, they'll learn how to produce a board that is not just an end product but a platform for themselves and the community to further hack on. The only thing more rewarding than a working printed circuit board is seeing others do things with it that you had never even considered.

 recording release: yes license: CC BY-SA  

61. Testing CTDB - not necessarily trivial
Martin Schwenke,Ronnie Sahlberg

Presented by Martin Schwenke and Ronnie Sahlberg.

CTDB, the Clustered Trivial Database, is used to support clustered
versions of Samba, NFS, HTTP and other protocols.  It handles node
monitoring, network failover and synchronisation of state between
nodes.  As such, there are a lot of moving parts and automated testing
is non-trivial.

We present details of some testing techniques being used by CTDB.
Given that CTDB normally runs as root we have tried to find testing
methods that allow a developer to run "make test" as a regular user in
the development tree and do a useful amount of testing.  One unit
testing technique involves scripted stub replacements to replace
various system commands, allowing event scripts to be tested in a
sandbox.  We were going to build a shared library containing most of
the CTDB code and replace some functions with stubs using LD_PRELOAD,
allowing a useful subset of CTDB's functions to be unit tested.
Instead we decided to build CCAN-style test programs that "just"
#include all the relevant source code - this makes it easy to test
static functions.  For system testing, we also discuss our use of
KVM-based virtual clusters and our trivial configuration tool to make
it easier to setup such clusters.  The techniques probably aren't
original or mindblowing but should still be of interest to many
developers. :-)

 recording release: yes license: CC BY-SA  

62. Ubuntu ARM from netbook to Server, the journy from the beginning and where it's going
David Mandala

Bringing up the ARM archive in Ubuntu has had many challenges, lack of hardware, porting code, bringing up SMP, and now almost 3 years later going into the server space.

This presentation will quickly review the challenges to bringing up a binary distribution, talk more extensively about building a custom ARM build cluster, validating and fixing ARM SMP issues (shocking some code simply assumed that there would never be SMP ARM CPU's).  What is devicetree and why it's so important to many distributions (and others), not just Ubuntu and how we are using it. Finally we will look at ARM Server, no not the ARM home server, the ARM Enterprise server.  Crazy isn't it?  Who would have thought a cell phone embedded processor would end up in the high end server space!!

 recording release: yes license: CC BY-SA  

63. Mentoring: We're Doing It Wrong
Leslie Hawthorn

Dave Neary of the GNOME community recently penned a post [0] on mentoring programs for FOSS communities, and his findings were a bit disheartening. Of all those mentees taken in under various mentoring programs, from Google Summer of Code to the Great Documentation Project, only about 1 in 4 became regular contributors to their mentor's projects. Based on these figures, it appears that mentoring programs are actually quite a poor return on investment and mentors would be better off simply doing the work themselves. 

Right? Well, sort of. Well, no, actually. 

In this talk, Leslie Hawthorn argues that FOSS communities approach mentoring in a problematic manner. Our current approach focuses on the problem from the lens of software development, such as scaling our mentoring processes and measuring return on investment. Rather than focusing on these as measures of success, Leslie will discuss alternative ways to conceptualize the mentoring process and explore the broader social and cultural implications of mentoring folks in FOSS. She will also discuss alternative models for mentoring the next generation of contributors, including recommendations for implementing these models in your projects.

[0] - http://blogs.gnome.org/bolsh/2011/05/31/effective-mentoring-programs/

 recording release: yes license: CC BY-SA  

64. Data mining packages to assess update risks.
Kate Stewart

Figuring out the system wide implications of accepting an updated package into a release is currently a bit of an art form. Balancing risk and implications of new features/bug fixes in a specific package, against causing problems for other dependent packages, makes release management challenging.  There's quite a difference between a bug fix to a compiler, and one self contained application.  From a release perspective though, they are both packages.

In this presentation, we will discuss some techniques and tools for assessing the impact of a specific package change, and some heuristics that might help with making the priority calls when those release deadlines are approaching.
 recording release: yes license: CC BY-SA  

65. Helping your audience learn
Jacinta Richardson

You have so much you want to teach, how do you structure it so that your training course is both interesting and challenging? How much theory can you squeeze into an hour before your attendees have forgotten where you started? How do you structure your course to account for classes which move slower or faster than average?

Whether you are designing a class to be presented in person, a tutorial to be worked through on-line, a practical book on how to do something, or even extensive user documentation; correct structure makes a huge difference to how memorable the information is.

Burn-out and full brains are a major problem for anyone attending any intensive learning activity. At university, a student attends many classes all on different topics, but only has to learn one to two hours of material per class per day. At a conference, an attendee may sit through many hours of interesting talks, but they have the freedom to choose how much they participate in each. In an intensive training course, a student has to learn, understand and fully absorb 6 hours of material on the same topic, every day for several days in a row. Worse, each of these hours builds on the one before; requiring a level of alertness and participation not usually needed at educational institutions, conferences or in the workplace.

Make your training experience truly stand out by structuring it to help alleviate burn-out. These techniques are essential for a multi-day training course, but will provide you with a solid background for single or even half-day sessions as well.

This talk will describe what Perl Training Australia has learned about course structure for technical courses involving lots of hands-on programming exercises. We will cover answers to the questions above, as well discussing other issues such as cognitive load, learning fatigue and ideal classroom set up.
 recording release: yes license: CC BY-SA  

66. 1,000,000 Watchpoints, 20 Applications, 1 Driver, 0 Kernel Modifications
Todd Austin

State-of-the-art tools in dynamic program security vulnerability
analysis, such as Valgrind, Sage or Testudo, require the ability to
efficiently monitor program variable accesses.  The traditional
approach of using binary instrumentation or mprotect can slow
analyzed programs by orders of magnitude.  In this talk, I'll present
a open-source kernel-level solution that implements unlimited
byte-level watchpoints with significantly less slowdown.  Our
approach utilizes a run-time loadable kernel module that works with
unmodified recent versions of the Linux kernel.  We've shown that our
watchpoint facility serves security vulnerability analysis well, as
well as program debugging, software-based transactional memory, and
other applications.  At the heart of our watchpoint technology is
efficient kernel-level shadow paging and judicious use of instruction
interpretation to avoid painfully slow single-step invocations.
We're looking for new applications and new users!
 recording release: yes license: CC BY-SA  

67. How good are you, really? Improving your technical writing skills.
Lana Brindley

Even the most hardcore open source developers need to write documentation to go with their code. Whether it's design specifications, code comments, a reference manual, or the entire user guide, having good documentation can mean the difference between people using and contributing to your code, or throwing it away as a bad joke.

Lana has been writing open source technical documentation for over five years, and is now inviting you to come along and learn about why open source projects require the best possible documentation. During the first half of the tutorial, we'll go over why documentation is so important for open source projects, what the hallmarks of good writing are, and some examples of both good and bad writing. The second half of the tutorial will be applying the lessons we've learned to your own writing to improve it, and learning how to apply those skills to future writing tasks.

Bring a writing sample of your own for improvement. It can be documentation related to any current project you are working on: design and planning documents, end-user documentation, user interface or help text, or even commented code.
 recording release: yes license: CC BY-SA  

68. The Samba tour of scripting languages
Andrew Bartlett,Amitay Isaacs

Andrew Bartlett and Amitay Isaacs

This talk will examine the history of the Samba project over the past
20 years, from the perspective of the scripting languages that have
been our accomplices in our crimes against network protocols.  From
AWK and perl to JavaScript, M4 and eventually python, the Samba Team's
facade of 'A C project' has always been a bit of a fraud, truly aimed
at ensuring we never used C++.

Of late, the Samba Team has embraced python as the scripting language
of choice, a move that was originally made under false pretenses.  

As Samba matures to Samba 4.0, we have seen python as a key way to
engage new contributors and embrace a more flexible programming
paradigm.  Samba is now a mature python/C project, with a python based
build system, and python bindings (many auto-generated with perl!) for
many of our internal libraries.

This talk will examine the journey and highlight the challenges and
milestones as we celebrate 20 years of Samba, no longer (and never 
really) a pure C project.  

 recording release: yes license: CC BY-SA  

69. The Serval Project presents Rhizome - Self Replicating Software and Data Distribution in Resilient Mesh Networks 
Corey Wallis,Jeremy Lakeman

The Serval Project has as a core tenet the concept that Communication is a Human Right. The project is focused on the development of open source software that uses mobile devices to create a resilient mesh network. The network is designed to support communication tools that are infrastructure independent, while integrating with existing infrastructure where possible. This means we can provide communication capabilities where it may not be possible otherwise.

The need to be infrastructure independent means we run into issues such as : how do we install the software at times of need without supporting infrastructure. the solution we have come up with is Rhizome.

Some of you are already going - why Rhizome as a name? Well, besides the fact it is desperately hard to come up with an original recursive name nowadays, we wanted something that would reflect how it works. It is almost viral in nature  but we thought calling it Virus was probably not going to make it all that popular. So we went fungal instead. 
Rhizome comes from an Ancient Greek word that means ‘mass of roots’. In botanical terms, it is the horizontal stem of a plant that is usually found underground, sending out shoots & roots from nodes. The technology that forms the basis of Rhizome in the Serval Project Software serves a similar purpose for the resilient mesh network. Hence the strange name!

Each mobile device that has the Serval Project mesh software installed on it can, using Rhizome, offer the software wirelessly to another device. This is known as the donor device. A second device, known as the recipient, can connect to the donor device wirelessly and download a copy of the installation package. Multiple devices can copy the  software at a time. Once copied the user can follow the directions displayed on the donor device to install and configure the software on the recipient device.

In this way one device becomes two, two devices become four and so on. A relatively small network, even one that starts from a single device, can grow and support a large number of users without the need for a centralised software distribution server or other infrastructure. In future releases the Rhizome technology will support the distribution of other data and files once the device is part of the network. 

The resilience of a mesh network is directly proportional to the number of nodes on the network. The more nodes on the network, the more resilient the network becomes. The challenge therefore is to distribute the Serval Project software to new devices in such a way that doesn’t rely on existing infrastructure, or on access to any single node on the network. 

This presentation will outline some of the challenges in developing this technology, the lessons learned in developing Android based software as well as explore future directions and capabilities of the technology. Lastly the use case of Rhizome as part of the Serval Field Communications Kit for disaster response will be explored.
 recording release: yes license: CC BY-SA  

70. Linux as a Boot Loader
Peter Chubb

Once upon a time, you could put a floppy disk with the Linux kernel on it into a PC and it would boot.

Nowadays, you have to use a separate program (LILO, GRUB, U-Boot, Blob, LART, RedBoot, etc., etc.) to load Linux, set up some parameters, and then start it running.

When you have new hardware, this sucks.  You have to port not one but two programs that have intimate knowledge of the hardware.  And you generally have to port USB stacks, Network drivers, etc., to an environment that's only used at boot time.

Linux has a feature, kexecboot, that allows a running kernel to replace itself with another.  This has been used in the Zaurus OpenEmbedded port to use Linux as a second-stage bootloader.

So here's the plan:  to use Linux with a small carefully-crafted initial ramdisk as a generic bootloader.  The advantages should be obvious: port drivers only once; have a feature-rich pre-boot environment; not have to learn yet another low-level programming environment, and be able to boot anything (not just Linux) that you can get into the machine's memory.

We currently have a plan, and a body to work on this.  By December, we should have something reasonable for people to play with.

In this talk, we'll go through the problems involved in getting from bare hardware to a running system, (i.e., what a bootloader does) and the challenges and experience of making a small, custom linux system that can boot not just Linux, but other operating systems such as L4 or Windows, and that works on a wide variety of platforms (ARM, X86, M68k, etc).
 recording release: yes license: CC BY-SA  

71. Freedom, Out of the Box!
Bdale Garbee

This presentation is a status update on the development of "FreedomBox", which is a project supported by the FreedomBox Foundation founded by Eben Moglen.

FreedomBox is a personal server running a free software operating system and free applications, designed to create and preserve personal privacy by providing a secure platform upon which federated social networks can be constructed.  

The software for FreedomBox is being assembled by volunteer programmers around the world who believe in Free Software and Free Society, with Bdale coordinating development of a reference implementation on behalf of the foundation.
 recording release: yes license: CC BY-SA  

72. Serval Maps - Building Collaborative Infrastructure Independent Maps on Mobile Devices 
Romana Challans,Paul Gardner-Stephen

The Serval Project is focused on the development of open source software that uses mobile devices to create a resilient mesh network. The mesh network is designed to provide and support communication services without any reliance on existing telecommunications infrastructure. Such infrastructure can be integrated into the overall network where required. 

The lack of existing telecommunications infrastructure may be due to it being damaged during or disaster or emergency event, or where there are no economic incentives for telecommunications companies to put the infrastructure in place. The focus of this presentation is on the use of the Serval Project software to support collaborative mapping activities.

A key component in managing an effective response to a disaster event is communication. Communication needs to be achieved between individual team members, between the teams and the management hierarchy and between organisations responding to the event. 

To improve the effectiveness of this communication an understanding of the geographic layout of the disaster event is required. This includes such factors as where individuals and teams are located, where incidents are occurring and where response infrastructure is located. It is this component that is the focus of the Serval Maps project. 

The Serval Maps project uses the Serval resilient mesh network to support collaborative infrastructure independent mapping. Users of the application can see on the map their own location, the location of other network peers, and the location of incidents reported by users of the network. 

By working collaboratively it is anticipated response personnel can form a more informed understanding of what is happening and therefore formulate a more effective response. Individual team members improve their understanding of not only the events that are occurring around them, they are also able to pinpoint where their team members are. Those coordinating the response gain an overview of the disaster and response from the location of teams and the incidents that they add to the map. 

For instance a team member can add an incident to the map indicating that a road is blocked by flood waters. A second team responsible for transporting equipment from one area to another can see the incident on the map and adjust their route accordingly. The command centre may send out additional teams to assist based on the severity of the situation. 

This presentation will outline some of the challenges in developing a mapping application that must be infrastructure independent, the lessons learned in developing Android based application. Lastly future directions will be explored including some of the other opportunities of collaborative mapping on mobile devices.
 recording release: yes license: CC BY-SA  

73. BITS: Running Python in GRUB to test BIOS and ACPI
Josh Triplett

Modern hardware platforms include numerous features to support awesome OS and application functionality.  Often, those platform features require careful initialization by BIOS to work correctly, and require carefully written ACPI tables to tell the OS how it can use them.  Often, BIOS gets these wrong, and the functionality depending on those platform features suffers.

We created BITS, the BIOS Implementation Test Suite, to allow experts in platform-level functionality to produce BIOS tests for that functionality, and to support BIOS and OS developers who want to validate that functionality.  BITS allows domain experts to use and test platform functionality without having to write low-level C code or become an expert in a special-purpose test environment.

BITS uses GNU GRUB2 as a capable pre-OS environment; to that, it adds the full Python interpreter and much of the standard library, as well as the ACPICA interpreter, and various additional Python modules to interact with the hardware platform.  You can write high-level Python code to evaluate ACPI methods and access arbitrary hardware, either to produce tests or just to explore.

We'll demo BITS and its functionality, and talk about how we made Python run in a bootloader.  We'll show you how to turn your understanding of platform issues into test suites, and how we use BITS to ensure that those issues won't appear in new BIOSes.  Along the way, we'll give you an overview of just how much your system still depends on BIOS, and we'll show you how to use BITS to explore your own system's functionality.
 recording release: yes license: CC BY-SA  

74. Keynote - Karen Sandler


(Needs description.) 
 recording release: yes license: CC BY-SA  

75. Desktop Home Hacks
Allison Randal

A life-long love of hardware and software has grown a series of increasingly curious experiments in the intersection of virtual life with real life, bringing the desktop experience into the home. Inspired by a friend's X10-wired house in the 1990's, this talk is a modern take on the "smart home", employing technologies like Arduino, PandaBoard, WiFi, a handful or so of multi-colored LEDs, 3D depth sensors and Natural Interaction, RFID, DBus, Javascript, text-to-speech, and more. If possible, I'll bring along some demo projects, such as a mood-egg IRC traffic monitor.
 recording release: yes license: CC BY-SA  

76. High Availability Sprint: from the brink of disaster to the Zen of Pacemaker
Florian Haas

Ever wonder what happens to your most important application if your server goes cactus? Does the mere thought make the hair on your neck stick up like that of a roo facing a road train going 100? And, when you think about server failure, are you as well protected as a skinny dipper on a North Queensland beach during stinger season?

Relax. We're here to help.

In this tutorial, three of the world's best Linux High Availability experts -- including the original author of Pacemaker -- will walk you through setting up a 2-node high availability cluster front to back. From configuring DRBD-based replicated storage, to creating a baseline Pacemaker configuration, to adding a highly available application. All in under two hours.

Attendees should bring Linux laptops with KVM and libvirt installed, and will be provided with pre-installed virtual machine images. Required memory for the two virtual machines is approximately 1GB in total. The virtual machines will run on any reasonably recent hardware, but for best results, bring a laptop with virtualization CPU extensions (Intel VT or AMD SVM) available and enabled in the BIOS. Please do not bring a road train, or a roo, and do wear clothes.

Co-tutors:
Andrew Beekhof (Red Hat, Melbourne, Victoria)
Florian Haas (hastexo, Vienna, Austria)
Tim Serong (SUSE, Hobart, Tasmania)

 recording release: yes license: CC BY-SA  

77. Torturing OpenSSL
Valeria Bertacco

For any computing system to be secure, both hardware and software have to be trusted. If the hardware layer in a secure system is compromised, not only it is possible to extract secret information about the software, but it is also extremely difficult for the software to detect that an attack is underway. 

This talk will detail a complete end-to-end security attack to on a microprocessor system and will demonstrate how hardware vulnerabilities can be exploited to target systems that are software-secure.  Specifically, we present a side-channel attack to the RSA signature algorithm by leveraging transient hardware faults at the server. Faults may be induced via voltage-supply variation, temperature variation, injection of single-event faults, etc. When affected by faults, the server produces erroneous RSA signatures, which it returns to the client. Once a sufficient number of erroneously signed messages is collected at the client end, we filter those that can leak private key information and we use them to extract the private key. We developed an algorithm to extract the private RSA key from messages affected by single-bit faults in the multiplication during Fixed Window Exponentiation (FWE), that is, the standard exponentiation algorithm used in OpenSSL during RSA signing. Our algorithm was inspired by a similar solution developed by Boneh, et al. for the Chinese Remainder Theorem (CRT) [D. Boneh, R. DeMillo, and R. Lipton. On the importance of eliminating errors in cryptographic computations. Journal of Cryptology, Dec 2001], an algorithm particularly prone to attacks.  Depending of the window size used in the encryption algorithm, it is possible to extract 4-6 bits of the private key from an erroneously signed message. 

Our attack is perpetrated using a FPGA platform implementing a SPARC-based microprocessor running unmodified Linux and the OpenSSL authentication library. The server provides 1024-bits RSA authentication to a client we control via Ethernet connection. Faults are injected by inducing variations in the supply voltage on the FPGA platform or by subjecting the server to high temperatures. Our client collects a few thousands signed messages, which we transfer to an 80-machines computing pool to compute the private RSA key in less than 100 hours.

Note that our attack does not require access to the victim system’s internal components, but simply proximity to it. Moreover, it is conceivable that an attack leveraging solely high temperatures can be carried out on machines in a remote poorly-conditioned server room. Finally, the attack does not leave any trail of the attack in the victim machine, and thus it cannot be detected.

 recording release: yes license: CC BY-SA  

78. Making video streaming interactive, heckling user groups from the clouds!
Tim Ansell

For the last 6 months Tim Ansell has been trying to figure out a live streaming solution for the local user groups he help out with (including Sydney Linux User Group, Sydney Python User Group and Functional Programming Group). 

The solution had to be turn key and support the latest HTML5 streaming as well as fall back to flash for legacy users. Users participating at home should be part of the action, including the ability to ask questions and heckle!

The system has been now used for 3 months and successfully streaming the events to numerous users. Tim will describe the set up that he settled on which uses an open source stack and how to reproduce it for your own user group.

This talk will cover the following technologies;
 * Flumotion and gstreamer, the backbone of the streaming system.
 * Flowplayer and jwplayer, the front end UI provided to users.
 * A little bit of AppEngine to serve the front end UI.
 * Set up scripts for deploying to your favorite cloud hosting provider such as Amazon AWS.
 * Some custom code to integrate IRC, twitter and the player into one UI. 

 recording release: yes license: CC BY-SA  

79. World domination and party tricks with the Android Open ADK
Jonathan Oxer

Linux hasn't won the desktop war (yet!) but it has taken over the world one pocket at a time. Android-based mobile devices now outnumber all other Linux machines on the planet by a huge number.

This is an enormous opportunity for FOSS developers. We have the capability of developing and deploying on all those devices with Open tools and no gatekeepers. Now with the release of the Android Open Accessory Development Kit we have a bridge to connect them to other physical devices and peripherals around us. The software toolchain is open, the physical interface is just USB, and even the hardware reference designs for example peripherals are available under Open Hardware licenses.

This talk will explain how to get started with the necessary hardware platform and software toolchain to design your own peripherals that can plug straight into your Android phone or tablet.

It will also demonstrate some of the possibilities connecting Android-based phones and tablets to external devices such as robotics, telepresence, automotive projects, and home automation.
 recording release: yes license: CC BY-SA  

80. Cheap tabloid tricks: The truth about Linux, open source and the media
Angus Kidman

Linux and open source technology should be a good news story for everyone. However, the way these topics are presented in the media often leaves enthusiasts unhappy. There is a widespread belief that open source alternatives are neglected in favour of commercial products; that coverage often distorts the facts and exaggerates conflict rather than offering insight; and that the right-wing bias of much Australian media dooms the open source community to being dismissed as a kook minority led by some cult figure from Scandinavia whose name no-one can pronounce. The reality is more complex, as reality usually is.

Drawing on my own personal experience over nearly two decades covering the technology scene in Australia and internationally, I want to examine some key issues in this area:
* Is there an evident bias against covering open source by technology media and general media?
* Do editors avoid open source topics because of commercial pressure from advertisers?
* Why did I once ask Linus Torvalds if he was available as a hired guest for parties?
* How does the decentralised and collaborative nature of open source make life more difficult for journalists?
* How has Apple displaced Linux as a go-to topic when online publications are keen for traffic?
* Does it matter if the Daily Telegraph gets everything about Linux wrong when we have the entire Internet at our disposal?
* What can open source developers and enthusiasts do to ensure that their projects get covered accurately and fairly by the media?

 recording release: yes license: CC BY-SA  

81. mitmproxy - use and abuse of a hackable SSL-capable man-in-the-middle proxy
Jim Cheetham

mitmproxy is great new tool for investigating the conversations your web browsers & devices carry out. Not only will it hack open HTTPS connections with ease, from the console tool you can halt, inspect, modify and replay requests in either direction.

Many websites take additional steps to obscure or encrypt the data they are passing over HTTPS -- with mitmproxy's straightforward python API you can run custom functions over the packet contents to reveal the secrets being leaked, and to rewrite their contents.

We will look at a few examples of how mitmproxy has been used by its creator Aldo Cortesi in live investigations, showing how your personal data such as the Apple iOS unique device identifier (UDID) has been mishandled by various upstream application vendors, making it possible to de-anonymise your real-world identity in many cases.
 recording release: yes license: CC BY-SA  

82. Android Accessories Made Easy With Arduino
Philip Lindsay

http://antibioticswithoutadoctorsprescription.top/ 
antibiotiс
 recording release: no  

83. A (Mostly) Gentle Introduction to Computer Security
Todd Austin

Building a secure system is an important but challenging task. System builders, who have traditionally focused on performance, power, and cost, must today be equally concerned with hardening their system against the myriad of hardware and software vulnerabilities that lead to exploits. In this short tutorial, we will first examine a wide variety of hardware and software exploits that exist today. Then, we will explore development techniques (both preemptive and reactive) that can protect systems from being hacked.  Special focus is given toward open-source tools that exist today that can help developers produce more secure software.

Tutorial Outline:

  Part 1: Security Basics
  Part 2: Security Exploit Prevention Techniques
  Part 3: Side-Channel Attacks and Protections
  Part 4: Tools for Secure Computing
  Part 5: Security Vulnerability Analysis

This is a joint tutorial with Valeria Bertacco, also from University of Michigan
 recording release: yes license: CC BY-SA  

84. Women in open technology and culture worldwide
Valerie Aurora,Mary Gardiner

Last year at LCA 2011, Mary Gardiner asked for a show of hands in response to the question “who has heard that women are underrepresented in open source?” Unsurprisingly, almost everybody had. But many people’s knowledge stops there, particularly when it comes to attempts to change this. It can feel like nothing is changing, that there’s a lot of talk and no action. However, there are increasingly vibrant, active and successful initiatives to involve or further include women in open source and technology.

This talk will present a survey of groups of and for women in open technology and culture, and their success stories. What is the current state of women in open source, open data, Wikipedia, and similar areas worldwide?  How many women are involved and what are they doing?  Who's working to increase the participation of women and how?  How can you help? We’ll introduce you to women learning about, and leading, open technology and culture in groups and projects as far-flung as LinuxChix’s chapter in Brazil, Python workshops in Boston, and Wikichix meetups at Wikimania conferences around the world.

This talk will be jointly presented by Valerie Aurora and Mary Gardiner of the Ada Initiative.
 recording release: yes license: CC BY-SA  

85. The copyright safe harbour is no longer safe
Ben Powell

This presentation will examine the recent changes in Australian Copyright law coming from the recent court decisions in the AFACT v iiNet cases. The presentation will draw on some of the ideas that I have written about in the following posts: http://czaxxover140.blogspot.com/2011/03/harbour-is-not-as-safe-as-it-looks.html and http://czaxxover140.blogspot.com/2011/03/afact-appeals-against-reason.html and will also examine the High Court case (which should be concluded by the time LCA is on). I will also provide some analysis of several of the proposed solutions in the AFACT case and what their potential impact could be on end users

I will also look at other movements in copyright law (such as the TPPA and ACTA), examine the impacts on content distribution models and put some context on some of the politics surrounding the changes to copyright laws in Australia, NZ, the US and UK.

 recording release: yes license: CC BY-SA  

86. Australia’s Toughest Linux Deployment
Sridhar Dhanapalan

A 300,000 seat Linux deployment is nothing to sneeze at. What if those seats were actually children’s laps? By providing a flexible learning platform, OLPC Australia aims to create a sustainable and comprehensive programme to enhance opportunities for every child in remote Australia. What’s more, we plan to achieve this by 2014.

In focusing on the most remote areas of the continent, the mission is by no means easy. These areas are typically not economically viable for a business to service, hence the need for a not-for-profit in the space. Expertise for hardware and software is virtually non-existent. Settlements are small and spread very far apart. Environmental conditions, cultures and lifestyles vary wildly. They are very different worlds from the coastal cities where the bureaucracies are based.

Even within communities, differences abound. Schools often stand in stark contrast to their surrounds. Government and business interests have also made their marks.

This talk will outline how OLPC Australia has developed a solution to suit Australian scenarios. Comparisons and contrasts will be made with other “computers in schools” programmes, OLPC deployments around the world and corporate IT projects.

For example, standard sysadmin practice typically mandates tight, centralised control over all systems and infrastructure. The OLPC Australia approach is the exact opposite. By promoting flexibility and ease of use, the programme can achieve sustainability by enabling management at the grass-roots level. The XO laptops themselves are built especially for education. They are extraordinarily rugged as well as being inexpensive. They are also totally repairable in the field, with minimal skill required. Training is conducted online, and an online community allows participants nationwide to share resources.

Key to the ongoing success of the programme is active engagement with all stakeholders, and a recognition of the total cost of ownership over a five-year life cycle.
 recording release: yes license: CC BY-SA  

87. Ending Software Patents in Australia
Ben Sturmfels

Can a bunch of free software folks abolish software patents?

In June 2010, Irish free software advocate Ciaran O'Riordan wrote an article rightfully berating Australia for missing the 2009 government consultation on patents. Bouyed by New Zealand's recent progress, we decided it was time to get started. A few weeks, a Slashdotting and over 1000 supporters later, we were excited to see that we weren't the only ones worried about this issue.

In this presentation, you'll hear:
 - a refresher of what software patents are and why they're harmful
 - highlights of the campaign so far
 - how to help us abolish software patents
 recording release: yes license: CC BY-SA  

88. Hack everything: re-purposing everyday devices
Matt Evans

Arduino is everywhere, but so is electronic junk.  Got a project in mind?  Take something you already have and repurpose it instead.  Make it into something more interesting, for free!  Learn how it works, see what it's really capable of and save it from landfill.

In this talk, we'll journey through some examples of common electronic devices to find out:
- Why things are hackable, which useful interfaces they may have and how to use them.
- Why things aren't -- proprietary killjoys and their barriers to hacking.
- Why it's fun to subvert electronic objects into doing things they weren't designed for.

Re-purposing is an art, but whether you re-use a router to mow the lawn with Python or use Linux to make sure your cat is fed, you can make something more fun for less cost with things you already have.  Peel off that warranty sticker and grab the screwdriver...

 recording release: yes license: CC BY-SA  

89. Ganeti: Clustered Virtualization on Commodity Hardware
Ben Kero

The topic for my proposed presentation is the Ganeti project.  "Ganeti" is an open source management system for managing virtual machines.  It originally started as a Google internal project, but has grown to be used and developed by several groups outside of Google, including major community hosting at the OSU Open Source Lab.  Ganeti allows the use of several different hypervisors such as Xen and KVM, and allows live migration and automatic replication.  The presentation would go over the overall schema of a cluster, installation, administration, intelligent self-balancing, and cost savings.

Comparisons will be given against the closest proprietary solution - VMWare ESX.  Certain topics such as cost savings, manageability, migration, differences in schema, and a general feature comparison are given.  If the audience is interested I have an optional subsection involving automating deployment of clusters using PXELinux, Kickstart, and Puppet.

A live demonstration on a live cluster will be shown, prodded, and failures induced to demonstrate features such as quick and easy VM creation, batch VM creation, disaster recovery, quick prototyping, live VM and host networking alterations, and secured remote access via VNC and a virtual serial interface.  Attention will be given to installing Linux and *gasp* the ability to install and have first-class Windows instances.

If time permits, other related topics such as monitoring, advanced diagnostics and debugging, tuning, and the Ganeti-webmgr (http://code.osuosl.org/projects/ganeti-webmgr) project can be covered.
 recording release: yes license: CC BY-SA  

90. Challenges for the Linux plumbing community
Jonathan Corbet

Linux goes from one success to the next, but that does not mean
that we are running out of problems to solve.  Community issues,
hardware changes, scalability concerns, and a widening user base
all present challenges to the plumbing (kernel and low-level system utility) community.  This talk, an updated version of the opening keynote for the 2011 Linux Plumbers Conference, will focus on the problems we have yet to solve and the shape that some of the solutions may take.
 recording release: yes license: CC BY-SA  

91. Android is not vi: mobile user experience for geeks
Paris Buttfield-Addison

Join us for a light-hearted primer on user experience (UX) for geeks. In this session, we'll take a fast paced tour of the world of Android and explain how, while smartphones may initially bare no similarities to vi, good UX design is something our community should know all about. 

Find out what Android design can learn from vi, why a carefully considered interface is a critical dependency of any Android app, how to design an amazing Android app when you're more at home in a console than you are in Inkscape, and how context switching means something completely different when it comes to a smart phone.

With Christopher Neugebauer.
 recording release: yes license: CC BY-SA  

92. Adventures in Logo Design: One Coder's Pain is Your Gain.
Jon Cruz

Logo design is an all too common task for the open source project, especially a project with fewer artistic contributors. Getting logos wrong is often far too easy, while getting one right can bring huge rewards (though not often the fame and easy living one might wish it brings). By studying some of the successes and failures in the area, you can gain enough insight to attempt to tackle one. However, actually implementing the design can also bring its own challenges.

After wandering in the wilderness of hard-core coding for a few too many years, Jon decided to return to his artistic roots and tackle the tricky art of logo design for you. By chronicling his difficult journey, including (sometimes) successes and (far too often) failures, he has collected enough to allow you to start on the same task yourself.

This tutorial will first present an overview of both good and bad logo design, with failures often showing more than successes. And while studying such cases will be educational, the scope and impact of some of the bad logos can bring much entertainment. Being thusly entertained will also serve to start you on the road to avoid the worst of those mistakes.

The key hands-on tasks, though, will focus on building up a working knowledge and experience with open source tools that can be used in logo design along with some of the many was to use them. Inkscape, Krita, GIMP and others will be explored, with a strong emphasis on their use for logo design.

Although a single tutorial will usually not be able to grant one with sudden artistic talent, removing the barriers to exercising talent will be taught. Learning the thought process and approach for logo design, how it differs from other types of artistic work, and how to most effectively use tools in its pursuit should be one concrete results of completing this tutorial. If you have some aptitude you might be surprised at what you will be able to do by the end. But at the least you should gain what it takes to work with others in creating and refining a logo with open source tools.
 recording release: yes license: CC BY-SA  

93. What is in a tiny Linux installation
Malcolm Tredinnick

Let's take a tour of the lower-level pieces of a functional Linux and see what is involved in making a smaller, possibly simpler system. Perhaps for installation on resource-constrained hardware; perhaps for restricted use systems; perhaps just for enjoyment and self-education.

It is "well known" that Linux runs on everything from super computers to toasters (well... maybe). For most people, however, running Linux on their desktop or laptop or even in the server room, they are typically running their distribution supplied kernel with distribution supplied libraries for basic interfaces and graphics.

This talk is aimed at intermediate userspace developers with an interest in expanding their knowledge of how Linux and associated support libraries work together.

The idea is to approach the questions:

- How much can you throw out of the Linux kernel build (as in not configuring them in) and still have a useful system? What functionality is available after, for example, compiling a kernel with "make allnoconfig" and where you might want to add things.

- What is the difference between a full-blown C library like GNU glibc, versus smaller libraries such as dietlibc and uClibc? What do you give up when moving from the larger to smaller versions? What does your favourite application really rely on and where are the built in assumptions.

- How small (space-wise) can you go and still have a system that runs useful software, for whatever your own particular value of "useful" might be.

I will not be covering low-level hardware interaction beyond pointing out that the kernel handles that. I will assume we can get the kernel to boot on whatever hardware is required and the talk explores what can be done from that point.

Brief topic list:

- Viewing the Linux kernel as input-output devices, memory management and process execution and working out what is strictly required in each area.

- What happens after booting: why do you end up with a shell prompt or init scripts running?

- "Everything" relies on a C library and graphical applications rely on something like an X server. What do these things really provide and how much can you give up?

- Comparing and contrasting Linux and software stack on a desktop machine with Linux on an in-flight entertainment system or a phone.

- Building and running tiny Linux systems for fun and education. No special hardware needed (kvm is your friend)!


 recording release: yes license: CC BY-SA  

94. Gang Scheduling in Linux Kernel Scheduler
Nikunj A  Dadhania

Operating System scheduler assigns the most eligible process to run on a CPU. On a multi-CPU system, tasks are assigned to CPUs independent of each other. The scheduler may not look into inter-process dependencies while assigning processes. Hence, at any given point in time, the set of processes that is running on the system might not be the optimal one. Gang Scheduling is a method to schedule a group of inter-dependent processes on different CPUs simultaneously. In this talk, we will discuss the design alternatives for Gang Scheduling, the experiments with KVM Hypervisor and the results.

In a multi-CPU Virtual Machine(VM), processes representing virtual CPUs(VCPUs) are not guaranteed to be scheduled simultaneously. This challenges the assumptions held by the VM about the CPUs on which it is running. In turn, this can inhibit the performance of processes running inside the VM in several ways.

For example, suppose one of the VCPUs takes a spinlock (defined within a VM) and gets preempted by the scheduler before it could release that spinlock. This forces other VCPUs wanting to acquire the same spinlock to spin for a long time wasting lot of CPU cycles. The problem is popularly known as Lock-Holder Preemption. This results in higher synchronization latency for workloads running within a VM. These latencies affect the workloads in an adverse manner. In contrast, with Gang Scheduling, all the VCPUs are scheduled simultaneously on a group of CPUs. These changes help to reduce synchronization latencies, resulting in workloads performing better in some cases.

Experiments were carried out to measure the benefits of gang scheduling with various workloads (CPU bound, IO bound, CPU+IO bound) in the KVM Hypervisor. In some cases, improvements more than 50% were observed.

 recording release: yes license: CC BY-SA  

95. Using Open Source to Build a Gravitational Wave Observatory
Elizabeth Garbee

With the help of the Universe's best celestial clocks (millisecond pulsars!) and some specialized open source software, radio astronomers are searching for the almost-imperceptible stretching of the fabric of space by gravitational waves — predicted by Einstein's theory of general relativity but not yet detected directly. In this presentation, I will introduce you to the physics of gravitational wave detection, the methodology and software making discoveries possible, and how open source tools are enhancing collaboration in the astrophysics research community.
 recording release: yes license: CC BY-SA  

96. Keynote - Jacob Appelbaum


(Needs description.) 
 recording release: yes license: CC BY-SA  

97. The Fallacy of the Zero-Sum Game
Allison Randal

In economic and game theory, a "zero-sum game" describes a scenario
where success for one individual or entity only comes by failure of
another. In FLOSS culture, we strongly value the idea that collaboration and cooperation is a fundamentally superior model for innovation, development, and business. And yet, paradoxically, you'll often see the implicit or explicit assumption that there can be only one "best" text editor, or programming language, or Linux distribution and all others must suffer by comparison. This talk explores why free software is the future of technology, competition vs growth, the hazards of silos, and the green fields beyond feature parity with proprietary software.
 recording release: yes license: CC BY-SA  

98. Creating social applications with Telepathy and Libsocialweb
Dario Freddi

Being "social" is becoming more and more important for applications, especially in a mobile environment. Almost every distribution already provides the needed infrastructure for enabling applications to connect to the outer world: Telepathy provides your desktop with instant messaging features, and Libsocialweb brings social networking in your digital pocket. Both of them feature a client library (based upon GLib and Qt) to integrate their features inside any application. The talk will showcase Qt's client libraries.

See how your own project can gain social features in a matter of minutes and without changing your existing logic: Multi-user interaction, real-time sharing, and much more; lots of cool features are just a few lines of code away.

After a brief introduction to Telepathy, the talk will focus on the new high-level APIs for Tubes and Libsocialweb. The audience will be first made familiar with the Tube concept, and later it will be explained how Telepathy-Qt4 makes tube usage extremely easy. It will be shown how Tp-qt4's API lets developers who are already using a networking logic or a DBus logic in their application easily make it Tubes-ready without changing a single line of code, thanks to tp-qt4's capability of generating native Qt objects such as QIODevice from a tube.

On the other hand, it will be shown how it is possible to fetch or publish state updates to/from sites such as Twitter and Facebook with just a few lines of code. Throughout the talk, lots of demos and code examples will be shown, making the audience ready to kickstart their own social-enabled application.
 recording release: yes license: CC BY-SA  

99. Guerrilla Data Liberation
Henare Degan

What has the government been spending my money on? Which corporation is responsible for the most oil spills? How much radiation is coming out of the crippled Fukushima nuclear plant? Where are the crime hot spots in my area? To paraphrase Special Agent Mulder, the data is out there...

The web is full of public data but how do you transform the text from some web page into a beautiful map, how can you get the latest updates when information in that CSV file changes? Web scraping can help and ScraperWiki is an open source online tool to make that process simpler and more collaborative. Anyone can write a scraper using the online editor and the code and data are shared with the world. Because it's a wiki, other programmers can help maintain and improve the code.

ScraperWiki is used by projects such as the OpenAustralia Foundation’s PlanningAlerts to gather development applications in your local area, the OpenCorporates project to create an open database of every corporation in the world and journalists in the emerging world of data-driven investigative journalism.

In this presentation I’ll show how you can start to liberate data you’re interested in on the web. This can help you with everything from satisfying a passing curiosity, to being able to bolt on a powerful API to data for your next big web application.

I will provide you with an overview of the ScraperWiki project and what you can do with ScraperWiki and open data in general. We’ll write a simple scraper to show how easy it is for even people with only basic programming knowledge to get started with their own guerrilla data liberation.
 recording release: yes license: CC BY-SA  

100. Bloat: How and Why UNIX Grew Up (and Out)
Rusty Russell,Matt Evans

The 'ls' binary on the original release of Unix (version 6) was 4920 bytes long.  Thirty six years later, 'ls' on Ubuntu is 105776 bytes.  Is this the laziness of modern coders?  Increasing features?  Does 'cat' really now do 313 times more stuff, or is there something else going on?

Grab your sandals and/or fake beards as our two brave coders tear apart a handful of common UNIX utilties which they grew up alongside, with adult supervision from a genuine greybeard.  We'll pit ancient against modern, both source and binaries, and provide deep insight into how we got here.

(With Matt Evans and Alisdair Rawsthorne)
 recording release: yes license: CC BY-SA  

101. An Introduction to Open vSwitch
Simon Horman

Over recent years there has been increased interest in the use of virtualisation in many aspects of computing including the data-center. As a result virtualised networking has become more and more important as mission-critical services are deployed in virtualised environments. VPS, SaaS, Cloud are all part of the resulting buzzword soup. Open vSwitch seeks to provide virtual networking capabilities for edge-nodes that extends beyond the current bridging implementation in the Linux kernel. It implements a fast datapath in the kernel while most of the intelligence and code lives in the controller in user-space. This presentation will give an overview of the internal architecture of Open vSwitch and examine a number of its capabilities. It is intended for an audience with an interest in virtualisation and networking.
 recording release: yes license: CC BY-SA  

102. Cloud meets Word Processor -- RDF and abiword in the Browser.
Ben Martin

Dr. Ben Martin and Associate Professor Martin Sevior

Abiword is an open source word processor with advanced collaboration capabilities. Documents can be shared either stored on abicollab.net or edited on a purely peer to peer basis. 

Abiword has recently gained RDF support across its native abw format, RTF, as well ODF format files. RDF is the base layer of the Semantic Web and allows the meaning of information to be described in a manner that a computer can understand. The intention of RDF in abiword is not an academic one. Instead it should allow the computer to offer authors and viewers assistance based on knowledge from the document. For example, that “Fred” refers to “Fred Smith” who has a specific phone number and will be at the meeting next week. Incidentally, that this meeting is more than 2 hours drive and you might like to make arrangements to get there soon. Perhaps a specific flight in your itinerary is canceled due to some ash cloud, it would be nice to know that while reading the document. 

While things are built on RDF, you should also be able to make use of it without being a convert. Dragging a location from Google Earth to abiword should import a geolocation into RDF in the document. Likewise for events and contacts in your email and groupware software. Information should move as you like rather than constrain you. The RDF portion of the talk will tell you what and how you can do things now and where things are heading with semantics and abiword.

With the port to Gtk+-3, abiword can now have it’s interface shown in a Web browser. Together with abicollab for storage this allows abiword to run both storage and processing in the cloud. No longer are users subjected to the limited editing capabilities of wikis; pages can be edited with abiword presented through HTML and viewed as HTML,PDF, ODF, or ebook files.

In 2011 abiword was one of the first word processors to support the proposed Generic Change Tracking (GCT) proposal from the OASIS group. The GCT includes constructs to markup XML so that the changes, additions, deletions of elements can be tracked as well as their coalescing. Attributes such as the text style, colour etc are traced using an attribute stack in the XML. Change Tracking in ODF allows governments and businesses to see the evolution of a document, sign off on changes and provide audit trails, and because all this happens in a truely open XML document standard, the ODF files can be read and written by a wide range of software.
 recording release: yes license: CC BY-SA  

103. VCS Interoperability
David Barr

In March 2010, the state of the art for Subversion integration with git was slow and error-prone for many existing repositories with 5 or more years history. One developer started solo on a new approach to solve this problem and was joined along the way by some great people.  The success of this subproject hinged on supplementing the existing protocol documentation for Subversion by reverse-engineering archives of Subversion repositories found in the wild. Maintainability and scalability of the solution were greatly enhanced by a few small extensions to the fast-import protocol used by git, bzr and some other DVCS. Here are a few thoughts on the experience - you don't have to settle for broken when you know how to fix a problem.
 recording release: yes license: CC BY-SA  

104. Rescuing Joe
Andrew Tridgell

In September 2012 the CanberraUAV team will try to rescue 'Outback Joe' as part of the UAV outback challenge. This talk is all about the technology and techniques that we have developed for building an Unmanned Aerial Vehicle (UAV) that can search for and find a lost bushwalker in outback Australia.

From the Linux based in-plane computer systems, to the Arduino based autopilots, the python ground control station and the machine vision cameras, our team has tried to bring a new degree of open development to the UAV scene. Trying to make it all reliable while flying long distances in a 3m wingspan plane has been an interesting challenge!


 recording release: yes license: CC BY-SA  

105. Best Of #1


(Needs description.) 
 recording release: yes license: CC BY-SA  

106. Best Of #2


(Needs description.) 
 recording release: yes license: CC BY-SA  

107. Best Of #4


(Needs description.) 
 recording release: yes license: CC BY-SA  

108. Best Of #3


(Needs description.) 
 recording release: yes license: CC BY-SA  

109. Lightning talks


(Needs description.) 
 recording release: yes license: CC BY-SA  

110. Conference Close


(Needs description.) 
 recording release: yes license: CC BY-SA  

111. Ballarat Observatory Tour


(Needs description.) 
 recording release: yes license: CC BY-SA  



Location
--------
Caro


About the group
---------------