pre-release: PyCon Australia 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: PyCon Australia at Room 103 Fri August 12, 9p


PyCon Australia
=========================
When: 9 AM Friday August 12, 2016
Where: Room 103

None

Topics
------
1. Scripting the Internet of Things
Damien George

A big part of the Internet of Things are the end nodes, such as sensors, that				
are controlled by microcontrollers or other small computing devices. These				
devices are getting more and more sophisticated and it can be beneficial to				
program them with a scripting language instead of a low-level language like C.				
Such scripting languages need to be implemented specifically to fit and run on				
a microcontroller and in this talk I will discuss a few of them: Python, Lua,				
JavaScript and Ruby. I will talk in detail about MicroPython, a lean and				
efficient reimplementation of Python 3 with a reduced standard library, that				
runs on microcontrollers and can be used to build Internet-of-Things devices.				
There will be plenty of time in the talk for questions and open discussion.				
 recording release: yes license: CC-BY-SA  

2. Smart City: Connecting the dots and digital kids
Roland Gesthuizen

Schools face a daunting challenge to increase their student
exposure to coding, hands-on technology learning to solve some
real-world problems and teaching STEM principles (Science, Technology,
Engineering and Mathematics) through design, construction and testing.
This personal presentation by a leading teacher illustrate journey to
connect his students to some real-world problems and the challenges
faced along the way. Following on from an earlier
computational-thinking challenge to build and program a moving
vehicle, Roland's current mission is to challenge students to design,
build a smart city consisting of intelligent vehicles and
infrastructure. To do this they need to program a navigation algorithm
to autonomously navigate vehicles through a series of traffic
challenges that test collision avoidance and road safety. They have
been invited to showcase their work at the ITS2016 Word Congress in
Melbourne with a maker-space for delegates to share our hands-on
problem solving and learning with the software and models developed by
the students. Moonshots live in a grey area between audacious
technology and pure science fiction. Our moonshot was to empower
students around the globe to build and control their future.
 recording release: yes license: CC-BY-SA  

3. Python's Bright Future in Science
Juan Nunez-Iglesias

Over the past five years, Python has skyrocketed in popularity in the scientific world, pushing out proprietary languages such as IDL and Matlab. This rise was powered by simple syntax and efficient numerical libraries. But many operations in Python are still slow, and upstart languages, such as Julia and Go, promise simplicity *and* speed. Can Python cement its place in scientific computing?
 recording release: yes license: CC-BY-SA  

4. Django & Drupal: A tale of two cities.
Donna Benjamin


Drupal and Django have much in common. They’re both open source tools for building the web. They’re also marked by some fundamental differences. However, both are so much more than that.

"Every human creature is constituted to be that profound secret and mystery to every other. A solemn consideration, when I enter a great city by night, that every one of those darkly clustered houses encloses its own secret; that every room in every one of them encloses its own secret!" - Charles Dickens.

Let’s explore the darkly clustered houses of these two different communities of open source people. 

 - What common challenges do we face?
 - What different approaches do we take?
 - What can we learn from each other?

And finally, what could we do together?
 recording release: yes license: CC-BY-SA  

5. Digitising 100 years of parliamentary data - Django as a framework for government data management
Samuel Spencer

Historical information on Australian Parliaments has been available in the Parliamentary Library's flagship publication the Parliamentary Handbook - an extensive almanac with biographies, tables and records dating back to Australia's federation. This data is used as a way to track key social issues, such as length of service, gender representation in parliament and historical election information in an authoritative format.

To improve access to this information the library began development of a mobile app which evolved into a complete Django-based data management system for managing parliamentary biographies and service histories based on Popolo, a civic data framework for the management and dissemination of parliamentary information. Along with interactive biographies and records of ministries and parties, the system for the first time allows users to build custom tables from complex queries that are dynamically updated as new information is made available.

Coupled with this is the development of a biographical data management system that will ensure that records of new parliamentarians and future changes to existing parliamentarians are captured in a single system.

In this presentation, we cover the challenges and successes in digitising over 100 years parliamentary data, including migration, data cleansing and data trust issues. We also provide a technical breakdown of the chosen framework and infrastructure, and issues during development especially when dealing with imprecise or incomplete historical records. Lastly, we cover the Django apps for data modelling and querying built for this project that have already been released as open-source.
 recording release: yes license: CC-BY-SA  

6. ESP8266 and MicroPython
Nick Moore

The ESP8266 is an exciting new WiFi enabled SoC which is not only small and fast but also very very cheap.  And now it can run Python!  This talk discusses the ins and outs of ESP8266 chips and modules, how to install MicroPython, and what you can do with it once you've installed it.
 recording release: yes license: CC-BY-SA  

7. Teaching Python: Ten+ Years of Successes, Trials and Tribulations
Bruce Fuda

Teaching programming has always been a challenge given the lack of experience, understanding and knowledge students in schools generally have about what is involved and what it means to be studying "IT". It hasn't been helped by a lack of robust curriculum in most states and territories in Australia. With the recent endorsement of the Australian Curriculum: Digital Technologies, most states and territories have implementation timelines as early as 2017, and this means that teachers (and those who want to support them in their classrooms) now have an obligation to deliver ambitious, engaging and rigorous learning activities in their classrooms. Having been in the enviable situation of being supported and encouraged to design and implement innovative computer science curricula for students in years 6-12, I'll be sharing the reasons why I choose to use Python as my primary teaching language in high school, and identify the tips, tricks and traps teachers need to watch out for when using it as the basis for learning not just programming skills, but computational thinking more generally. This includes an explanation of the importance of a project-driven approach, and demonstration of the techniques I use and projects my students work on in class.
 recording release: yes license: CC-BY-SA  

8. Python for bridging between researchers and service operators: from CFFI to Jupyterhub
Kevin Plastow

This talk will give an overview of a water forecasting system, which exposes via Python a suite of tools developed in C++ for hydrologists to use. 

PySWIFT is a Python software system that allows the use of SWIFT (Short-term Water Information and Forecasting Tools), a hydrologic suite of tools for flood and short-term streamflow forecasting.

When integrating the SWIFT C++ system with Python, we aimed to achieve two main goals: 
1. Provide a productive and interactive environment for hydrological modelling.
2. Take advantage of a complex multi-threaded C++ suite of tools that enables rapid execution.

To achieve the first goal, we created a modelling environment using JupyterHub. In this environment, modellers can set up, run, inspect and modify models, which is ideal to conduct exploratory experiments with the models. 
To achieve the second goal, we used CFFI to create a Python wrapper for SWIFT’s API. CFFI allows us to interact with SWIFT’s C interface. 

In this presentation, we will highlight the challenges and learnings that came about whilst building this system.

 recording release: yes license: CC-BY-SA  

9. Teaching Python with Minecraft
Digital K

Minecraft is one of the best selling video games of all time. So, why not use it as a tool for teaching Python?

Instead of clicking to place blocks, students can create giant shapes, structures or even games within the game by learning some basic Python code - and along the way, key programming concepts. 

This presentation will cover how it works, and what you need to set this up for school or home. We'll look at examples of coding projects, how it can relate to other subjects in the curriculum (such as maths and design), and discuss why this is a great tool for introducing beginners to text-based coding.

No prior knowledge required, although some familiarity with the Minecraft game and/ or text-based coding will be useful.

Recommended for teachers or parents of students in Years 5 - 12 who are at a beginner or intermediate stage of learning programming.  Budding young coders also welcome!
 recording release: yes license: CC-BY-SA  

10. Controlling a 3D printer with Python
James Stewart

Additive manufacturing ("3D printing") has already proven to be a revolutionary technology in industries as diverse as medicine, architecture, industrial design and aerospace.
                                                                                                                                                
At the same time affordable consumer-grade printers have put 3d printing increasingly within reach of the general public.                       
                                                                                                                                                
However the user interfaces of most 3D printers still leave something to be desired. Interaction is generally performed via a monochrome LCD and jog dial. Network connectivity is often an afterthought with file transfers primarily performed via SD Card.   
                                                                                                                                                
OpenGB is an Open Source 3D printer control interface. It was developed in conjunction with re:3D as part of the Open Gigabot project but was designed to work on a variety of Open Source 3D printers.
                                                                                                                                                
In this talk James Stewart will describe the OpenGB backend which is written in Python and acts as an intermediary between the network and the printer. Various technologies are employed including:
                                                                                                                                                
* Tornado                                                                                                                                       
* Websockets                                                                                                                                    
* JSONRPC                                                                                                                                       
* Multiprocessing
* pySerial
                                                                                                                                                
As well as 3D printing enthusiasts, this talk will be of interest to anybody using Python to control a lower-level controller such as Arduino.  
 recording release: yes license: CC-BY-SA  

11. Building brains
Paula Sanz-Leon

The Virtual Brain (TVB) is an open-source scientific software written in
Python for advanced simulations of complex brain dynamics. TVB can be used in
a client-server configuration, such that its web-based interface can be
accessed remotely, or as a standalone cross-platform Python library through a
scripting interface. 

In this talk I will begin by briefly explaining the motivations and science 
behind TVB. This will be followed by a description of TVB's architecture and 
main functionalities, including: simulation of neural activity; modification 
and visualization of brain connectivity and network dynamics; and, analysis 
of time-series. Lastly, I will show you that getting started with brain 
simulations is just one Jupyter notebook away.

With TVB you might not be able to build smart brains (yet), but you can build
one of the most realistic approximations to the physics of a human brain.

 recording release: yes license: CC-BY-SA  

12. Behind Closed Doors: Managing Passwords in a Dangerous World
Noah Kantrowitz

Secrets come in many forms, passwords, keys, tokens. All crucial for the operation of an application, but each dangerous in its own way. In the past, many of us have pasted those secrets in to a text file and moved on, but in a world of config automation and ephemeral microservices these patterns are leaving our data at greater risk than ever before.

New tools, products, and libraries are being released all the time to try to cope with this massive rise in threats, both new and old-but-ignored. This talk will cover the major types of secrets in a normal web application, how to model their security properties, what tools are best for each situation, and how to use them with major web frameworks.
 recording release: yes license: CC-BY-SA  

13. MicroPython: Embedded programming for everyone
Jim Mussared

Embedded programming allows students to take their programs into the physical world - to build robots and interactive gadgets with sensors and displays. Until recently, this has been almost exclusively the domain of lower level languages like C which is not known for its beginner friendliness.

MicroPython is an optimized implementation of Python 3 designed to be run on the sort of embedded microcontrollers that are making their way into the classroom, allowing Python to take the place of C. In particular, the BBC MicroBit, the pyboard and the ESP8266 all now support MicroPython.

By using a language that students are already familiar with, more time can be spent on fun things like building robots and less time debugging code or setting up development tools.

One of the problems with teaching embedded programming in a classroom environment is the equipment required - both the actual boards and any additional accessories or modules. We will also demonstrate a browser-based MicroBit simulator which makes embedded programming accessible to more students and also allows for the creation of structured lessons, problems and assessments.
 recording release: yes license: CC-BY-SA  

14. GPS Tracking with Python
Caleb Hattingh

Python is very well-suited to implement GPS tracking services.  Devices need to report position data to servers, and Python handles this role well, especially with the new support for asynchronous event loops in Python 3 which can handle tens of thousands of simultaneous connections.  In addition, the struct module in the Python standard library makes short work of processing binary data supplied by devices. In addition to basic interaction with tracking devices, this talk will also present methods of integration (server) testing using py.test, as well as considerations regarding support for both UDP and TCP protocols in the same stack, since different GPS tracking devices may prefer one or the other.
 recording release: yes license: CC-BY-SA  

15. Geoscience Big Data Computing with Python
Fei Zhang

Python programming language is extensively used in Geoscience Australia (www.ga.gov.au) for scientific computing. In particular, a datacube system has been developed recently using Python as a core technology. The system manages petabyte-scale earth-observation satellite imagery datasets. And has enabled a wide range of applications such as the Water Observation from Space.

This talk is about how Geoscience Australia applies scientific computing (Python) to the big data challenges.

 recording release: yes license: CC-BY-SA  

16. Search-First Writing for Developers
Heidi Waterhouse

If people can't use your software, you have already failed as a developer. 

This talk digs in to how optimizing for search and using the existing technical assistance forums can put your product ahead of the pack. Technical writing, in all its variations, is a type of interface with your product. It incorporates everything from an error message to an implementation guide. How can you as a developer make deploying, using, and promoting your product as painless as possible? Make it searchable. Make finding the answer to a problem so trivially easy that your user barely even remembers they had a problem.

No one wants to be using software. They want to be data mining or manipulating beautiful photos or targeting advertising. Making them think about the software diverts them from what they want to be accomplishing. Use these documentation techniques to get them in and out and on their way.

(my secret is: I'm always angry when I have to read help)

 recording release: yes license: CC-BY-SA  

17. Integrating 2 factor authentication into your project
Markus Holtermann

Most websites these days require some kind of authentication. User name + password is the most common one. OAuth with Facebook / Github / Google / Twitter is also common. But sometimes you can't rely on 3rd party services and user name + password is not enough. In those cases 2 Factor Authentication is a nice, additional security layer. Use e.g. a phone to ensure a more secure authentication.
 recording release: yes license: CC-BY-SA  

18. OpenBMC: Boot your server with Python
Joel Stanley

OpenBMC is an open source software project that replaces the Baseboard Management Controller firmware that is responsible for turning off and on, and managing the health of your server. The core of the software that performs these functions is implemented in Python, allowing easy to read, modify and debug firmware that is traditionally not accessible to a user. 

This talk will cover the architecture of the OpenBMC and demonstrate how easy it is to support a new server platform by writing a few lines of Python.
 recording release: yes license: CC-BY-SA  

19. Integrating Python within a School Context
Brad Nielsen

Python is an ideal first programming language for secondary school students due to the simplicity of its syntax, its enforced code formatting, and the extensibility of the language. Introducing Python to a school however, takes planning, an incremental approach, and modification to existing curriculum plans based on experience. In this presentation, you will be given an overview of how a high school has introduced Python through years 8-12. You will also learn about various Python packages and environments that can be of benefit to a school including: Python Turtle, Grok Learning, Pygame, Flask, and PythonAnywhere.  
 recording release: yes license: CC-BY-SA  

20. Data Science Design Patterns
Tennessee Leeuwenburg

Most 'data science' projects fall into just a few well-understood design patterns. This talk de-mystifies what those patterns are, how to use them practically, and how to get to grips with your data. We'll a look at how to understand the input/output structure of the models, how to design a reasonable 'experiment', and how to get started. We'll look at getting to grips with problems by simple data sets that can fit entirely on-screen, designing the basic 'form' of the machine before levelling up to bigger data and badder algorithms.

All of this will be shown using Python tools, libraries and running code.
 recording release: yes license: CC-BY-SA  

21. The Internet of Not Great Things
Nick Moore

The Internet of Things! Existential menace or meaningless buzzword?
Automating away drudgery or just eroding privacy? Cornucopia or Panopticon?

We'll look at the poor state of the current IoT in terms of 
security, privacy and interoperation.  We'll consider a set of 
requirements for a better IoT.  And we'll look at what
we as Pythonistas can do to improve on this, as a community
and an industry.

 recording release: yes license: CC-BY-SA  

22. Breaking up arrays up into chunks for fun and science with Xarray and Dask
Andrew Hicks

Xarray is n-dimensional array package bringing numpy and pandas-style interfaces to labelled data.  Its main use is for manipulating scientific datasets stored in NetCDF file format.

The Dask package brings task graphs for parallel computation of arrays, by breaking them up into smaller chunks, for lazy processing of arrays. It can handle larger-than-memory dataset, scaling from a single machine to a cluster.

When used together, then can be used to analyse all sorts of scientific data.  This talk will look at using them to analyse a timeseries of Earth-observation from Landsat satellites.
 recording release: yes license: CC-BY-SA  

23. Django - Customise your SQL
Josh Smeaton

Learn about the different methods of altering the SQL that the Django ORM generates. Write complex reporting queries, perform calculations within the database, or drop down to writing the entire query in pure SQL. Take advantage of your specific database features.
 recording release: yes license: CC-BY-SA  

24. Teaching geometry using Logo/Python turtle module, or how to sneak programming into maths class
Vivian Li

With the new national curriculum for Digital Technologies, there is a fantastic opportunity (and in some schools, need) to teach programming in conjunction with other learning areas. Python is an ideal first language, and there is a natural and deep relationship between mathematics and computer science.

We used the Python’s Turtle module (an implementation of Logo) to create resources that integrate the Year 7 Geometry topic and the basics of Python programming in a way that’s highly engaging for students. Learn about how we integrated the two subject areas and the results of our pilot run with a cohort of Year 7 students in NSW.
 recording release: yes license: CC-BY-SA  

25. Using Jupyter notebooks to develop and share interactive data displays
Ioanna Ioannou

Presented with Maoyuan Liu from the Bureau of Meteorology.

Jupyter notebooks have become a very popular tool for scientific data analysis and exploration. Often notebook users may produce a data analysis within a notebook and decide they wish to share it with a wider audience. While notebooks offer excellent facilities for data visualisation, they are less than ideal as a medium for sharing these visualisations more broadly. Interacting with data in a notebook requires knowledge of programming. Notebooks with static data displays are more accessible to non-technical audiences, but static displays severely limit the breadth and depth of data that can be explored within one notebook. So the question arises: How can we provide our audience with the ability to explore our data?

Developing interactive data displays for the web typically requires knowledge of web technologies that notebook users may not possess. To bridge this gap, a flurry of recent activity has focussed on the development of tools that facilitate interactivity within notebooks. Such tools include interactive plotting tools that enable actions such as zooming and selecting of data within plots, user interface elements (eg. drop-down menus, sliders) that can be incorporated into notebooks, and tools that facilitate the arrangement of plots and information into dashboard-like displays.

My team at the Australian Bureau of Meteorology has used these tools to build shareable interactive data displays comparing weather forecasts against observations across Australia. In this talk we will review currently available tools that facilitate interactivity within notebooks, share our experience in using them, and the practices we have developed around their use. A simple step-by-step example will demonstrate how we can put together an interactive data display allowing selective plotting of data through UI controls and interaction with the plots.
 recording release: yes license: CC-BY-SA  

26. Doing Math with Python
Amit Saha

The talk aims to highlight how Python is the perfect programming language to make programming more fun and immediately applicable to young learners. By making use of standard library modules such as the fractions module, third party packages such as matplotlib and sympy, the audience will learn how to write programs to solve common math problems. Some of the topics that will be discussed are:

- Simulating uniform and non-uniform random events
- Drawing Fractals
- Solving algebraic equations and inequalities
- Solving calculus problems
 recording release: yes license: CC-BY-SA  

27. A Bird, A Guitarist And A Raised Platform Walk Into A Bar: Comparing Wagtail, Django CMS and Mezzanine
Adam Brenecki

Django CMS, Mezzanine and Wagtail are the three most popular Django-based content management systems; all three have kept (or, in Wagtail's case, gained) their popularity because they are so different to each other. In many ways, from their fundamental data models right through to how they approach their content editing UIs, each one has a very different take on how a CMS should work.

This talk will explore the different approaches, strengths and weaknesses of each CMS, and what they mean for you as a developer and for your content editors.
 recording release: yes license: CC-BY-SA  

28. Working with real-time data streams in Python
Lachlan Blackhall

An increasing number of devices and applications are producing vast amounts of data in real time. This can include measurements, sensor readings, and performance data.

Making this data useful often requires that we analyse and use the data in real time but this requires techniques to aggregate, filter, and smooth the data. Drawing on simple and well-tested techniques from mathematics and engineering allows us to solve these problems quickly and efficiently.

This talk will describe how Python can be used to develop powerful capabilities for working with real-time data streams and provide simple examples you can start using yourself.

 recording release: yes license: CC-BY-SA  

29. Python at Terrace
Tim Stephens

The development of the Digital Technologies curriculum and the shift from ICT to DT has dramatically changed the teaching of computing in schools. This change has challenged teachers to find new solutions and software to assist them in their teaching of the curriculum. Some schools have employed Python as a way of meeting these challenges and requirements outlined in the curriculum documents.
The band description 8.6 states that  by the end of Grade Eight students should be using a general purpose language to code solutions. At Terrace we decided to use Python to achieve this outcome because of Python’s ease of deployment, cost and syntax light approach. Students in Grade Eight use the turtle and functions to write their name and create shapes. In Grades Nine and Ten the band description states:Students develop modular solutions to complex problems using an object-oriented programming language where appropriate, and evaluate their solutions and existing information systems based on a broad set of criteria including connections to existing policies and their enterprise potential. To achieve this we get students to program classes and databases. Students create a piece of software that creates customers for a bank or a character creator for an RPG. Students design, implement and evaluate the software that they create. In this presentation I will share the successes and failures over the past five years and provide people with software options, programs of work and ideas for Grades Eight to Ten when using Python. 
 recording release: yes license: CC-BY-SA  

30. Multi-modal interaction with the real world using Python and the Internet of Things on Amazon Web Services (AWS
Adam Larter

AWS IoT is a managed cloud service that enables Internet-connected things to easily and securely interact with each other and the cloud. This session will introduce you to the AWS IoT features, how you can build your IoT solutions on the AWS Cloud, and how to make use of the AWS IoT service even if you are not developing for physical devices, using Amazon Cognito and AWS Lambda for web sockets notifications in the browser. We will dive deep into how the Amazon Web Services platform makes it easy to create applications that interface with the Internet of Things using Python as a first-class language on devices and the back-end.  We’ll demonstrate real implementations that use multiple modes of control, from movement and light intensity, to manual and voice control and engage the audience with two-way interactivity with minimal infrastructure to manage.
 recording release: no  

31. Taking Django beyond HTTP
Andrew Godwin

Django's new Channels feature takes Django beyond the world of HTTP's request-response protocol and into the modern Web protocol world of WebSockets and real-time communication - but it also does a lot more. Learn how Django can now respond to WebSockets, emails or instant messages as easily as HTTP, and we re-architected Django to support all these changes while keeping a clean API and backwards compatibility, and the implications it has for the wider Python ecosystem.
 recording release: yes license: CC-BY-SA  

32. Big data biology for pythonistas: getting in on the genomics revolution
Darya Vanichkina

In 2001 Bill Clinton unveiled "the most important, most wondrous map ever produced by humankind" - the human genome. This monumental endeavour cost $3 billion, and took hundreds of scientists from all over the world 13 years. Today, a single person can generate such a map in ~2 days for $1000. This dramatic drop in cost means that we now have data for hundreds of thousands of people - and other species - from all corners of the globe, and cohorts are available for every major disease under the sun. Petabytes of new data are also being generated every day.

Most of this data is publicly available, so anyone with an internet connection can try in silico biology from the comfort of their own home. In my talk, I'll walk through what this data looks like, and how it's analysed - with a special focus on where python fits into the workflow (;tldr the most interesting parts!). I will also highlight some common pitfalls software engineers and developers face when getting into this space. Finally, I'll showcase several other facets of bioinformatics that sorely need contributions from good coders.

Genomics is rapidly entering the world of health care in both the public and private hospital sectors, and in direct-to-consumer genetic testing. Understanding this data, the challenges and limitations of its analytics will help us all make better-informed health and medical decisions, affecting our quality of life and those we love.
 recording release: yes license: CC-BY-SA  

33. 402: Payment Required. Micropayments for IoT
Mitchell O'Neill

What if you could provide access to sensor data in exchange for small amounts of payment, or give your devices a stipend and they could autonomously engage in commerce with in a marketplace of machines?

Payment solutions for microresources thus far have either required cumbersome aggregation, billing and centeralised metering or have been deemed too cheap to meter. We'll explore technology that could reduce this friction such as the bitcoin blockchain and open source python libraries that allow your devices to engage in micropayments in a fast, trustless and cheap manner.
 recording release: yes license: CC-BY-SA  

34. Django Reduxed 
Saket  Bhushan

The talk will be an introduction to all the moving parts involved in building 
a client side isomorphic single page application with a REST backend. We 
will take a dive into How and where does React-Redux fit into the bigger picture 
of REST APIs and Client Side MVC, and how to seamlessly introduce the goodness 
it brings to your django project. We will also see some non obvious things that you had 
to deal while using redux.

Having a service oriented architecture in web projects require interfacing the
backend using a REST-ful interface. Building your website as a single page app
allows you to focus on building the API up front, rather than duplicating your
efforts to build a website and then replicating the functionality with an API.
With a single page app, your website can be constructed in much the same way as
a mobile app. Django and the Django REST Framework enabled my team to quickly
deliverable a highly functional REST API that was customised to our unique needs.

React is a great tool to keep UI organised, but won't keep
track of the data and state of application. Redux comes to rescue over here -
it defines a minimal but sufficiently powerful way of interacting with that state.
An action from the UI is combined with a simple JS object(state).
Redux helps developers manage the state and flow of data around an application.


One of the strengths of redux is that everything is very explicit.
It ease out the process of managing the state and flow of data
around an application. Imagine tons of asynchronous actions without introducing
annoying UI bugs.
 recording release: yes license: CC-BY-SA  

35. Exploring Kivy in the classroom - GUI and App development for Python
Amanda Hogan

Graphical User Interface with Python is a tricky business. Come and learn a bit about Kivy and learn about my successes and failures using it with my Senior Software Development students (in NSW) to introduce GUI and App development with Python. 
In this workshop you'll be introduced to the Kivy library, the tagging and formatting in kv files, setting up the python classes to support the UI and passing parameters between them.
The workshop is not really suitable for the Python beginner because we need to play around with classes and methods (one of the challenges with using it in the classroom) but will otherwise be a fairly measured pace.

 recording release: yes license: CC-BY-SA  

36. A Girls Guide To Growing A Moustache with Python
Heidi Baxter

The objective is to showcase the power and flexibility of combining preexisting python modules and apply them to the field of facial detection and machine learning.
Correctly positioning a mustache on any given face in a straight forward and fun example of applying the technology in a 30 min presentation

To use an elementary task as a vehicle for explaining and demonstrating the complexities of shape recognition, object classifiers and machine learning.

I will demonstrate the use of image pyramids for image scaling and blending.
The histogram of oriented gradients (HOG) is a feature descriptor used in computer vision and image processing for the purpose of object detection.
Finding the location of different facial features (e.g. corners of the eyes, eyebrows, and the mouth, the tip of the nose etc.) accurately will be described. 
Facial landmarks are used to align facial images to a mean face shape. How this allows the blending of images will be described and demonstrated.

If you are a girl and want a mustache, you can’t just grow one, so you have to steal one.
I developed this project on raspberry pi and python. I wanted to do something different on that platform. I felt there were too many people who used their Rpi to feed their dog, water their plants or play MP3. I knew the platform had more potential than that. Hopefully this talk will help people think differently about Rpi3.
Attendees will learn tips on image processing, as well as training your own object classifier. 
Showcasing the power of python in a fun, lighthearted way. Hopefully, being informative and entertaining.

 recording release: yes license: CC-BY-SA  

37. To Be Advised


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

38. Lightning Talks


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

39. Designing hardware APIs to facilitate hands-on learning
Andreas Antoniades

Through experimentation with educational hardware and software, Obelisk Systems has identified the need for, and developed a brand new framework to allow students (both university and high-school) fluid interaction with complex hardware within classrooms. This framework is further implemented into an API that handles all low-level sensor access whilst maintaining relevance to a wide variety of students.
This API will be used to interface with space experimentation and education hardware being developed by Obelisk Systems.
 recording release: yes license: CC-BY-SA  

40. Learning TensorFlow
Robert Layton

The recently released TensorFlow library has caused great waves in machine learning circles, with its powerful syntax that allows for distributed computation, improved efficiency, and modularisation. The framework allows you to build graph-based models, such as those used in machine learning and artificial intelligence, and have those models run on a distributed computing systems, including GPUs.

This talk will cover what TensorFlow is, why/when you should use it, and cover the basics surrounding Variables, Placeholders, and Custom Functions. Importantly, there are several use cases *not* focused on data analytics - TensorFlow is more than just a machine learning library!
 recording release: yes license: CC-BY-SA  

41. Intentionally Blank


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

42. MicroPython: a journey from Kickstarter to Space
Damien George

MicroPython is a lean and efficient reimplementation of Python 3 with a
reduced standard library, and brings the awesomeness of Python to computing
devices with few resources, such as microcontrollers.  In this talk I will
detail my journey in building MicroPython and the various projects that it
has been used in and the people who are using it.  I will talk about running
a successful Kickstarter campaign (actually two of them!), circuit board
manufacturing, working with the European Space Agency, working with the BBC
on the micro:bit project, and the challenges of managing and funding
open-source software.  There will also be some live demos!

 recording release: yes license: CC-BY-SA  

43. Intentionally Blank


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

44. Ruruki in-memory graph database
Jenda Mudron

Graphs allow you to map data in ways that is interesting and effective. They allow you to look at data in new ways and ask interesting questions that you have not yet considered. Graphs are effective in a sense that they naturally grow as data is added.

One interesting thing that I found about using graphs, is that you can relate any types of data to each other. For example, say that you have a network graph representing servers connecting to switches which connect to routers, and so on. You can then introduce the software layer linking applications to servers, and how they connect to other applications. Then you realize that people need to administer servers, networks and applications. So you then introduce people to the graph outlining who is responsible for what. Now the power of graphs come in because you can ask questions like if RouterA breaks, who do I need to contact and what applications are affected.

Before committing to something more concrete like Neo4j, you may want to prototype a proof of concept first, or in my case validation where you make changes, test it, correct mistakes, and then commit to a reliable source. Ruruki was developed to be just that. An in-memory graph database for rapid prototyping and a temporary throwaway graph database.
 recording release: no  

45. RULES FOR RADICALS: CHANGING THE CULTURE OF PYTHON AT FACEBOOK
Jason Fried

Today, services built on Python 3.5 using asyncio are widely used at Facebook. But as recently as May of 2014 it was actually impossible to use Python 3 at Facebook. Come learn how we cut the Gordian Knot of dependencies and social aversion to the point where new services are now being written in Python 3 and existing codebases have plans to move to Python 3.5.  All without official support or sanction.

"Rules for Radicals" is a book for community organizers by the late Saul Alinsky on how to unite people to effect positive change in their communities.
 recording release: yes license: CC-BY-SA  

46. Why would a new developer choose Django?
Josh Simmons

What makes new developers choose Django over Rails or WordPress? As a web developer and community organizer, Josh has learned a lot about the differences between the frameworks and why people make the choices they do.

We'll compare Django with other ecosystems to see where it excels and where it lags. You'll leave with a better sense of the web ecosystem as a whole and why people are choosing things that *aren't* Django. Critically, attendees will leave with specific ideas about how to attract more new developers.
 recording release: yes license: CC-BY-SA  

47. Warpdrive, making Python web application deployment magically easy.
Graham Dumpleton

Ask a beginner to deploy a Python web application and they will often complain it is too hard. Although we have standards for how a Python web application should interface with a web server, the web servers for Python all work differently, with a myriad of options and being difficult to set up properly.

In this talk you will be given a preview of a project called 'warpdrive', a project being developed to simplify the process of deploying a Python web application.

The 'warpdrive' project makes it easy to run your Python web application on your own system, but it can also create a Docker image for your application, providing you with an easy path to deploying it on a Docker service.

How 'warpdrive' works is also compatible with next generation Platform as a Service (PaaS) offerings such as the latest OpenShift, which has been reimplemented around Docker and Kubernetes.

Come see how working on and deploying your Python web application could be made so much easier using 'warpdrive'.
 recording release: yes license: CC-BY-SA  

48. The Power ⚡️ and Responsibility 😓 of Unicode Adoption ✨
Katie McLaughlin

Communication is difficult.

Whether it’s between humans or machines or a combination of the two, trying to translate meaningful information is a lossy process.

Converting languages to use the new Unicode standard is hard, but once it's in place, you get this marvellous feature-add: Emoji compatibility. No longer do we have to make faces with symbols, or be forced to platform-specific emoticons! Rejoice in the extended character set!

Emoji has a rich history as a way to allow the communication of ideas in a reduced amount of data, and dates back to a time where this was important: SMS communications in Japan. However, as social networks feverishly try and clamber into this bandwagon, their implementations of the standard create more issues with miscommunication that aren't already possible with a 12x12 pictograph. 🤔

From the technical to the social aspects, mojibake and UTF-{8,16,32}, this talk will cover why the extended character set provided by the Unicode standard needs to be treated with responsibility by users and platforms alike.

This talk is not just an excuse to see what parts of the conference stack can’t handle Unicode, I promise. 😇
 recording release: yes license: CC-BY-SA  

49. Python for Bioinformatics for learning Python
Martin Schweitzer

In this talk I will explain why Python is an excellent language for learning about bioinformatics.  I intend to make a compelling case in favour of using Python as a first language for teaching bioinformatics. 

I will then explain how bioinformatics can be a useful vehicle for learning Python.

Finally, we will visit a site where users can learn both Python and bioinformatics in a stimulating, engaging and motivating environment.

The talk will assume familiarity with Python, but does not assume any knowledge of bioinformatics.  


 recording release: yes license: CC-BY-SA  

50. Python for science, side projects and stuff!
Andrew Lonsdale

There are many serious reasons why Python is a great language for scientific research but in this talk I will propose an alternative reason; Python is great for scientific research because of all the other non-scientific things you can do with it!

Research data can take a long time to generate, and researchers may never know when certain programming skills will be needed. Since you’re going to procrastinate on side projects anyway, using Python in those side projects is a great way to improve your skills until they are needed. Using my own experiences in computational biology research,  I’ll go through how the use of Python for web scraping and data visualisation in several diversions, distractions and other side projects ultimately helped my research. 

I’ll also outline how the general-purpose nature of Python can come in handy for teaching and outreach, and how packages like Django can allow for efficiently creating infrastructure around research data and analysis.  There is more to research than doing research, and more to scientific programming in Python than the usual suspects in SciPy. In this talk I’ll argue that using Python for side projects and harebrained schemes is essential preparation for all of the other legitimate reasons to use Python to solve scientific problems.
 recording release: yes license: CC-BY-SA  

51. Tutorial: Technical Blogging for Python Programmers
Thursday Bram

This tutorial will cover how to write about your programming projects for an online audience, whether you're promoting your projects, recruiting open source contributors, or building up a blog to impress employers. We'll briefly cover the mechanics of blogging, then dive into how to write effectively about technical topics. 
 recording release: yes license: CC-BY-SA  

52. Linear Genetic Programming in Python Bytecode
Mark Burgess

A quick tutorial on genetic programming and its implementation in Python.
Including the general process of evolution, the various representations of programs and particularly linear genetic programming.
Some really basic python libraries are introduced, including the DEAP and pyevolve frameworks.
It has been presented and prototyped by github user mgard (and documented http://multigrad.blogspot.com.au/2014/06/fun-with-python-bytecode.html) that python bytecode itself could be directly evolved in linear genetic programming to alleviate the overhead of compiling the permutations of trees generated by the evolutionary process.
Python bytecode itself is redly accessed and created by Cpython, though not compatible between versions and a subset of python bytecode instructions will be selected for the implementation of a basic example of symbolic regression.
A futher and more useful example will be provided.
 recording release: yes license: CC-BY-SA  

53. Graphing when your Facebook friends are awake
Alexander Hogue

Look I’m not really sure why but I think I made a thing that makes graphs of when people are online on Facebook. It sounds kinda creepy and uh it is. We'll talk about the struggle of finding a good graphing library, so come along and roleplay as  the NSA. ˙ ͜ʟ˙
 recording release: yes license: CC-BY-SA  

54. From Flying Circus to Holy Grail: Migrating the Twilio API from PHP to Python
Sam Kitajima-Kimbrel

Almost every software project of meaningful scale eventually runs into architectural problems. One of the larger issues we’ve dealt with at Twilio is an increasingly-brittle and hard-to-manage PHP codebase, originally responsible for running a website and public REST API. Rather than risk a from-scratch rewrite of the entire system, we chose to extract small and well-defined chunks one at a time into simple services using a common internal interface standard.

Given a new fleet of services and a set of internal REST APIs, how do we get to parity with the existing public API specifications? Rather than force every service to implement authentication, data validation, rate-limiting, and so on, we chose to build a simple federation service to translate and proxy customer requests to internal systems. Python was a natural choice for this application due to its flexibility, extensive library and testing ecosystem, and suitability for rapid prototyping and development.

But: how did we get from A to B? This talk will cover the details of Twilio’s past and current API architecture, how we adapted the service-oriented architecture pattern to build a consistent public interface, and the testing and deployment strategies we used to migrate 5 billion monthly requests from old to new systems with no downtime. 
 recording release: yes license: CC-BY-SA  

55. Fail Early, Fail Often, Fail Well
Josh Simmons

It happens. Things go south and it’s not even clear how. Your client and you can’t see eye to eye, or your enthusiastic new business partner has dropped off the radar. The project you’ve invested weeks, months, or years into may never see the light of day.

Failure comes in many forms and the increasing complexity of our projects and the world they operate in doesn’t help. Despite our best efforts, learning the hard way is often the only way. Perhaps this is why modern startup culture has rallied around the mantra: “Fail fast. Fail early. Fail often.” But I spent the better part of my career failing in freelance, agency, and startups, and the experience leads me to believe the common refrain to be lacking.

Like gymnasts who train to fall properly, I believe we must learn to fail well. In this talk, I draw from my experience learning the hard way, flagging the ten easiest and most insidious mistakes one can make. Because failure is inevitable, I will also be sharing a framework for recovery that includes managing yourself, your relationships, and your reputation.

Attendees will leave with a better sense of what NOT to do, an idea of how to cope with failure, and the knowledge that failure is inevitable and that’s OK.
 recording release: yes license: CC-BY-SA  

56. Every Millisecond Counts: Performance & UX
Davey Shafik

How do you lose 900 million dollars in 100ms? Or 8 million visits in just 4/10 of a second?

User expectations are higher than ever when it comes to web performance, so much so that we've created an entirely new application architecture just to make it feel like our websites are faster than they actually are.

This talk will look at how we can improve our users experience at any scale through performance optimizations at every layer of the stack, from backend to browser.
 recording release: yes license: CC-BY-SA  

57. Security Starts With You: Social Engineering
Tiberius Hefflin

Virus? There’s an app for that. Malware? There’s an app for that. Social engineering? It's a little more complicated. These techniques, used by hackers to gather information on their target, are hard to combat without education - so why don’t we talk about them more often? Aimed at the average user who could be targeted by such an attack, this talk discusses the tools of social engineering, how it can be combated and why so many companies fail in preparing their employees for such an attack.  
 recording release: yes license: CC-BY-SA  

58. Automated deployment of Python packages for development
Andrew MacDonald

The ability to automatically deploy development and test versions of software supports a rapid development/release cycle.

Within our section of the Bureau of Meteorology we have a number of internal Python packages, ranging from small simple packages to large applications that are dependent on the smaller packages. We manage the development cycle to ease deployment of these packages and applications into development, test, and production environments.

Elements of our process are:
    * Source code management (git)
    * Code review (Gerrit)
    * Continuous integration (Jenkins)
    * Internal PyPi servers (Apache)
    * A development environment for automatic deployment of every Gerrit approved commit (Anaconda environment via Jenkins)
    * Versioning (git tags + versioneer)
    * Test environment for every tagged version (Anaconda environment via Jenkins)
    * Production environment for specified releases (Anaconda environment via Ansible)
 
A key benefit of this process is that we have a deployed Python environment for the latest development version of all packages, a pinned collection of packages for testing, and an approved stable collection for production. The development and test environments are rapidly updated when commits are approved in Gerrit or tagged. The production environment is then readily updated with specific versions after a period of testing in the test environment.
This presentation will discuss our development process, how it works for us and how we leverage Python packaging to do it.

 recording release: yes license: CC-BY-SA  

59. I wish I learnt that earlier!
Rachel Bunder

Python is an easy language to learn. Many Python programmers just picked it up thinking “It can’t be too different from X, just with indents!”. By learning a language this way you don’t discover the features unique to that language. 


In this talk we’ll take a tour of Python features that are easily missed. This includes list comprehension,  generator functions and the PEP documents. Where appropriate time comparisons between different methods will be given. 
 recording release: yes license: CC-BY-SA  

60. Behind Closed Doors: Managing Passwords in a Dangerous World
Noah Kantrowitz

Secrets come in many forms, passwords, keys, tokens. All crucial for the operation of an application, but each dangerous in its own way. In the past, many of us have pasted those secrets in to a text file and moved on, but in a world of config automation and ephemeral microservices these patterns are leaving our data at greater risk than ever before.

New tools, products, and libraries are being released all the time to try to cope with this massive rise in threats, both new and old-but-ignored. This talk will cover the major types of secrets in a normal web application, how to model their security properties, what tools are best for each situation, and how to use them with major web frameworks.
 recording release: yes license: CC-BY-SA  

61. More testing with fewer tests
Clinton Roy

We all wish we were were testing more, but tests are ugly, a pain to write and are brittle. Property based testing helps to solve all of these problems. Now, with Hypothesis, Python has an outstanding toolkit to write property based tests. 

With Hypothesis, instead of writing individual tests, you describe properties of your code and Hypothesis generates the test cases for you. This frees you from writing repetitive and error prone test cases. Hypothesis will generate many more test cases than you'll ever be able to bare writing, and will find more bugs.

Hypothesis has plugins for Django and numpy to help you generate test cases for these two frameworks.

 recording release: yes license: CC-BY-SA  

62. Python for Water Forecasting Services
Daehyok Shin

Since 2008, the Bureau of Meteorology has developed several modelling systems to support its streamflow forecasting services. These systems include MSDM (Modified Statistical Downscaling Method) and WAFARi (Water Availability Forecasts of Australian Rivers) for the Seasonal Streamflow Forecasting service (http://www.bom.gov.au/water/ssf), STAR (Streamflow Toolkit for Australian Rivers) for the 7-Day Streamflow Forecasting service (http://www.bom.gov.au/water/7daystreamflow) and HRS toolkit for the Historical Reference Stations (http://www.bom.gov.au/water/hrs). These systems routinely ingest recent observation data, fetch climate forecasts, run rainfall-runoff models and provide updated forecasts through publicly available websites. We chose Python as the primary programming language to build the main components of these systems, and used open source packages for scientific computing including NumPy, Pandas, Matplotlib, PyTables and IPython. Python was used as the glue to integrate different system components, and as a bridge to connect scientists and IT programmers. This approach resulted in a highly productive collaboration with CSIRO and university partners. It also fostered effective communication between hydrologists and system developers. In this presentation, we will describe how these modelling systems were built up and currently operate within the Bureau, and also explain how the use of Python was a key factor for successful development and operation of these forecasting systems.
 recording release: yes license: CC-BY-SA  

63. Imposter Syndrome
Bianca Gibson

Ever thought ‘oh no, they are all going to realise that I have absolutely no idea what I’m doing’? If so this talk is for you. I’ll cover some of the signs of imposter syndrome, how to minimise it’s negative    impact and how to reduce those feelings in yourself and others. 
 recording release: yes license: CC-BY-SA  

64. CPython internals and the VM
Christopher Swenson

Ever wanted to know what CPython, the standard Python interpreter, is doing under the hood? What happens at startup before your code is run? How is your code translated to VM bytecode, what does that bytecode mean, and how is it run? In this talk, we'll dive into all of those fun parts!

This will help you understand what your code is doing under the hood, how to potentially optimize it, and to know the advantages and disadvantages of CPython and how they affect you.
 recording release: yes license: CC-BY-SA  

65. SSL all the things
Markus Holtermann

Over the last few years SSL/TLS encryption of websites has risen tremendously. The Let’s Encrypt organization makes that pretty easy. And you can use it, too. For free! In this talk I'll show how to integrate SSL/TLS and point out some common pitfalls.
 recording release: yes license: CC-BY-SA  

66. Error handling without fear
Martin Matusiak

If you're like most developers you have a difficult relationship with error handling. You try to do "enough of it" to make your code work, but fundamentally errors make you uncomfortable and you want to avoid them as much as possible.

This is a logical reaction to errors when we first started programming - most errors were mistakes in our programs. But as you mature as a programmer errors are increasingly circumstances outside your control, and good error handling is essential to writing good code. It is the part of the iceberg under water.

This talk will teach you how to accept errors as something that is natural in any program and how to start thinking about error handling as part of "what your program really is about", rather than being a chore.

We will look at common classes of errors in domains like input validation, using libraries, and managing disk and network io operations, and discuss appropriate error handling strategies in each case. We will also discuss what kinds of errors we shouldn't try to handle at all, and why.

Finally, we will talk about how to approach testing error handling code and the pitfalls of overly clever error handling. 
 recording release: yes license: CC-BY-SA  

67. The dangerous, exquisite art of safely handing user-uploaded files.
Tom Eastman

Every web application has an attack surface -- the exposed points of interaction where a malicious or mischievous user can commit malice, or mischief (respectively). Possibly nowhere, however, is more vulnerable than places a user is allowed to upload arbitrary files.

The scope for abuse is eye-widening: The contents of the file, the type of the file, the size and encoding of the file, even the *name* of the file can be a potent vector for attacking your system.

The scariest part? Even the best and most secure web-frameworks (yes, I'm talking about Django) can't protect you from all of it.

In this talk, I'll show you every scary thing I know about that can be done with a file upload, and how to protect yourself from -- hopefully -- most of them.
 recording release: yes license: CC-BY-SA  

68. Intentionally Blank


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

69. Designing Hardware with Python - A story of the HDMI2USB.tv project...
Timothy Ansell

Python is generally considered a high level language a long way from hardware, this very fact actually makes it an awesome tool for helping out with the design and creation of hardware!

This talk will hopefully cover;
  * Python hardware description languages (HDLs) for creating "gateware" for FPGA chips or even real IC design.
  * Python scripting for hardware schematic layout and design rule checking.
  * Python tools for deploying, programming and debugging embedded systems.
  * Some cool projects like the HDMI2USB.tv (open source hardware for video capture) which use many of the above parts.

This talk will focus on open source tools.
 recording release: yes license: CC-BY-SA  

70. Lightning Talks


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

71. Tutorial: A Practical Introduction To Machine Learning
Sam Hames

Machine learning is a hot topic, with lots of hype about what it can and might do. Given the broad landscape of machine learning, and the continuing proliferation of new tools and techniques it can be difficult to get a pragmatic view of how machine learning can be used, or even where to start.

This tutorial will provide a high level introduction to machine learning: what it is, what kind of problems we can solve with it, and how can we apply it. In doing so this tutorial will also introduce the scikit-learn library and show you why this library is a central part of the machine learning ecosystem in Python.

We will start from scratch with a small example dataset, and walk through the process of building and carefully validating a classifier with scikit-learn. The practical focus during the tutorial will be on hands on implementation and experimentation. The technical focus will be on machine learning algorithms as black boxes for making decisions.

Assumed background: This tutorial only assumes that you are comfortable with Python the language. We will *not* assume that you have any maths background, or that you are familiar with numerical computing: discussion of maths and algorithms will be strictly limited to hand waving.


About Jack

Jack Simpson is a PhD candidate at the Australian National University working on image processing and behavioural analysis. He received his Software Carpentry Instructor training over a year ago and since then has organised and taught multiple workshops university.

About Alistair

Alistair Walsh is a cognitive neuroscientist currently working at The University of Melbourne, Research Platforms department as a Community Manager. He teaches Python, machine learning and text and image processing to researchers who aren't from a computer science background but need to use programming tools in their research. Alistair is also an instructor trainer for Software Carpentry and has run Software Carpentry programming workshops in Melbourne, Sydney and Adelaide.
 recording release: yes license: CC-BY-SA  

72. Intentionally Blank


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

73. Intentionally Blank


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

74. Python All the Things
Russell Keith-Magee

We’re familiar with Python as a scripting language, as a web server language, as a teaching language, as a data analysis language, and as a teaching language. But is that the limit of where Python can be used? What is the future for Python on other platforms? Is the prospect of using Python on those platforms a novelty, or a viable way to fend off an existential threat to the language? And how does this threat intersect with other threats we have to our community, and to our industry?

 recording release: yes license: CC-BY-SA  

75. Intentionally Blank


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

76. Hear no evil, see no evil, patch no evil: Or, how to monkey-patch safely.
Graham Dumpleton

Python is a dynamic programming language and has a strong tradition of adhering to a programming style called duck-typing. This means that it is possible to easily modify an application's code while it is running. One might wish to do this for various reasons, including enhancing the functionality of code, correcting errant behaviour, or adding instrumentation or debugging code.

Making such code modifications can be tricky though and not done correctly can potentially interfere with the operation of the original code, through destroying introspection abilities, not honouring the duck-typing mantra or due to being applied at the wrong time.

If you do need to do monkey patching though, the 'wrapt' library is your friend, with its transparent object proxy wrappers and post import hook mechanism, it allows you to safely monkey patch code to modify its behaviour.

Come learn about the 'wrapt' library and the joys, but also the dangers, of monkey patching.
 recording release: yes license: CC-BY-SA  

77. From Humanities to Tech: How a Religion PhD came to be learning Python
Lauren Bernauer

Despite studying Physics, Chemistry, and the compulsory Maths at High School, I ended up in a Arts degree at University, and from there majored in Studies in Religion and History and continued on to do postgraduate research degrees in Religion. But along the way I became employed in IT and since completing my PhD have been teaching myself Python (among other things). However all these years in the Humanities have resulted in a particular way of approaching learning, one that is not entirely helpful to learning programming. In addition to this, there is also how I can make my new skills relevant to all those years of research and study?

This talk is going to be about my own journey from a STEM high school student, to a humanities researcher, and then to IT, and what I have learnt along the way. It is also about why (I think) teaching children about computers and programming is incredibly important. And also, what I am doing, and planning to do with my new found Python skills in relation to my PhD and potential further research.

 recording release: yes license: CC-BY-SA  

78. How digital agencies can invest in open-source products without going broke or insane
Greg Turner

Compared to single-project software teams, digital agencies face the challenges of having to balance limited capacity amongst competing clients and projects, which makes it difficult to find time between the billable hours to invest.

However, agencies also have a whole lot to gain from building reusable code - chiefly scalability. If an agency's reusable code can become a product that offers value to clients, then agencies can move beyond hourly-rate pricing towards value-based pricing.

But creating products is expensive and risky, and open-sourcing products is even more so, until the benefits start accumulating.

This talk covers learnings from our 7 years as a Python/Django web agency, moving from using open source to contributing and creating it; what guides our investment decisions, and why some decisions worked and some didn't, and how our philosophy has shifted as a result.
 recording release: yes license: CC-BY-SA  

79. Evaluating fire simulators using Docker, Dask and Jupyter notebooks! 
Nathan Faggian

Bushfires are one of the most destructive forces in our environment. A major responsibility of the Bureau of Meteorology is to provide information on weather conditions that could make bushfires difficult to fight. Fire agencies then use simulators of fire behaviour to inform finer grained warnings to protect the Australian public. Objectively choosing the best performing simulators, or indeed the best versions of the same simulator, with respect to end-user requirements is a difficult task that requires a large amount of computation. 

The introduction of new tools like Docker, Dask and Jupyter notebooks make the task of large scale computation much easier! The Bureau of Meteorology is looking at these technologies to help modernise its legacy workflows and processes, one example is our recent work in the area of fire simulators.

This talk will work through the approach developed for a reproducible environment (using Docker) and then how we form workflows (jupyter notebooks) that execute fire simulators on a small compute cluster of both windows and linux hosts (Dask, Distributed).  Finally, we will work through an example of scaling up an experiment and demonstrate a process that is easy to replicate and follow for fellow scientists. 

 recording release: yes license: CC-BY-SA  

80. Starting fires in national parks - A proof of concept Python toolkit for effective landscape fuel hazard management
Henry Walshaw

Since the 2009 Victorian Bushfires there has been a major funding increase to allow fuel reduction burns in national parks in NSW. The first recommendation (Review of performance targets for bushfire fuel management on public land 2015) is that the government moves towards a risk reduction target rather than the current hectarue target. An evidentiary method of proposing burns based on ISO 31000 Risk management - principles and guidelines (2009) was built into a manual workflow using Esri's ArcGIS suite. The next step was to automate the process as much as possible. To do this we built a suite of tools using Python in ArcGIS and in Pandas. This meant that we could spend more time making sure our calculations were correct and we understood the data rather than spending time re-creating ways to read tables and perform calculations.

In this talk we'll cover the suite of tools we built and a workflow for a user, and what this means for environmental policy in the department and NSW. We'll talk about ways we step between automation and using tools like Excel which our Environmental managers are very familiar with, but which don't always lend themselves to consistent input. And we'll talk about how building this suite not only does the calculations for us, but also records the metadata at every step along the trail, so we can provide evidence of how we made our decisions.
 recording release: yes license: CC-BY-SA  

81. Code the Docs: Interactive Document Environments
Paris Buttfield-Addison

Distributing example code and applications with documentation is now easy. There are a million different ways to get code to people: from zips, to GitHub, to gists, and beyond. Code is easy to distribute. But how do we create a better link between example code, and written documentation?
Luckily, clever boffins have come up with some solutions: interactive document environments. These let the live code and the documentation sit side-by-side with one another, the distributed example code is the documentation.

This talk will take a brief look at some of the different interactive document environments out there – mainly Jupyter, IPython Notebooks, and Swift Playgrounds – and the various strengths, weaknesses, and caveats of these tools. We’ll also explore the future, and discuss where these tools are going, as well as the implications for technical documentation. Learn how to add interactivity to your documentation, and why this might be a good idea!
 recording release: yes license: CC-BY-SA  

82. Have It Your Way: Maximizing Drive-Thru Contributions
VM (Vicky) Brasseur

They drop by, they fix their particular problem, they leave. They're the drive-through contributor. While, yes, we all would prefer that these people stick around and join the community, there's no denying that a good drive-thru contribution adds value to your project. 

A strong argument can be made that the more drive-thru contributors your project has, the healthier the project process and ecosystem. It shows that you've set up a process which is easy to understand, easy to follow, and which makes it easy to contribute. In a situation like that, it increases the opportunities for new contributors to become new community members and everyone is a winner.

This talk will present:

* Methods for maximizing drive-thru contributions
* Overall advantages of those methods for your project
* An argument for using number of drive-thru contributions as a metric for project health
 recording release: yes license: CC-BY-SA  

83. Pyrobuf and the Tyranny of Speed
Gregory Saunders

The data structures used to represent information and program state in memory are rarely conducive to the storage and transmission of that information and state. The process of translating those data structures into a format better suited to storage is known as serialisation or marshalling.

Google’s Protobuf is a mechanism for serialising and deserialising structured data. Pyrobuf is a alternative, lightning-fast, implementation of Protobuf written in Cython that is 2-4 times faster than Protobuf when using its C++ backend and 20-40 times faster than its pure Python implementation.

In this talk we’ll briefly review Protobuf and compare it to other well known serialisation mechanisms such as XML and JSON. We’ll then take a look at Pyrobuf and the basic strategies it uses to achieve significantly better performance.

Pyrobuf’s main claim to fame is its speed. This makes fixing bugs and adding new features a real challenge as any degradation in performance will not be well-received by users who’ve come to expect and rely on its speed. Therefore, for the remainder of the talk we’ll discuss tricks and tips, some more legitimate than others, for maintaining speed as new features are added.

 recording release: yes license: CC-BY-SA  

84. Deciding between continuity and change in your Open Source community
Christopher Neugebauer

When you’re a big, for-profit project, it can be easy to justify a change from outdated software to the new hotness: figure out why the old software isn’t working for you, do a cost-benefit analysis, and – if it still seems like a good idea – make the change.
When you’re a community of volunteers, that justification can be less clear: cost-benefit analyses will rarely be about money. Worse still, the human costs can be difficult to justify: It’s difficult to get volunteers to do more unpaid work than they’re already doing. If your community depends on Open Source software, you get the added political difficulty of needing to navigate the divide between large-scale change and making small improvements to systems your community actively contributes to.
Whilst the motivation might be different, the process isn’t: leading a community towards change means understanding why existing systems aren’t suitable, making your community enthusiastic about the need for change, and then actually making that change.
To help make this point more concretely, we’ll look at how and why linux.conf.au – a long-running Open Source conference in Australia – effected a move away away from a bespoke legacy conference management software to one based on Symposion, the popular Django-based software created for the Python Software Foundation. We’ll also look at how that’s led to the PSF funding Registrasion, a Django-based conference sales platform.
With this case study as a guide, we’ll talk about how to make a decision to replace the software that your community runs on. In particular, we’ll cover how to identify and engage with stakeholders within a community; the value of prototypes in maintaining interest; and what a cost-benefit analysis might look like when your currencies are human joy, and burnout prevention.

 recording release: yes license: CC-BY-SA  

85. Reproducible Research in Python
Jodie Burchell

You’ve seen a great idea on someone’s blog that you think would really push that old analysis you did 6 months ago to the next level. You open up the Dropbox folder you have with all of your scripts, and … you’re lost. Which script did you start with? What does this random chunk of code do? Where is the original data file? You finally sort out your scripts, but then your code fails every second line because you don't even remember which packages you used before. Frustrated, you give up.

What if I told you that there is a better way to keep track of your analyses, and that it is easier than you think to do so? In this talk I will show you how using a reproducible research approach to your analyses can save you hours of time when revisiting or updating old projects, and demonstrate some of the tools that Python has available to make this possible. This talk will cover how to manage your packages using virtualenvs, how to thoroughly document your analysis using Jupyter Notebook, how to keep track of any changes using source control systems like Git and how to collaborate effectively using GitHub. By the end you will wonder why you’ve ever done your analyses any other way, and will be happily maintaining and improving your projects for many years to come!
 recording release: yes license: CC-BY-SA  

86. Click: A Pleasure To Write, A Pleasure To Use
Sebastian Vetter

We have a wide variety of packages and modules in Python that help build 
commandline tools in different ways. One of the more recent contenders is
'click'. It uses a very intuitive approach to create simple CLIs as well as
complex ones. In this talk, I will introduce building CLIs with 'click' and
illustrate some of its advantages.
 recording release: yes license: CC-BY-SA  

87. Python on Windows
Peter Lovett

Some of us working in the corporate world are required to use Microsoft Windows.
How can we bring the goodness of Python to the Windows platform?
What are the problems you could encounter and how can you solve them?

- wail at install directory problems!
- scream at path separators!
- cry at the craziness of special window installers
- revel in the beauty of lovely help
- marvel at the joy of py launcher and a proper #! line
- be terrified at accessing the winapi through the win32 libraries
- be astonished at Python taking control of Excel / Word / Outlook / Acrobat through the COM interface with win32com
- laugh at batch files!



 recording release: yes license: CC-BY-SA  

88. A Project-Driven Approach to Teaching Python: A Showcase of Student Work and Achievements
Bruce Fuda

One of the greatest advantages the teaching of the Digital Technologies has over most other schooling disciplines is the ease and speed with which students can see the result of their learning. New knowledge and skills go from being concepts they've never seen before to working code and applications very quickly, resources to assist them are everywhere, and feedback throughout the learning process is immediate. This presentation demonstrates some of the work graduating students from my Year 12 class have produced in their final year - projects that demonstrate mastery of computer science concepts like path finding, Bayesian spam filters, Markov chain-based predictive text generators and Artificial Intelligence algorithms. With the right support and guidance, students can go from programming novices to Python ninjas in a time frame as short as two years. Come along and see what high school students are capable of, and how we can help them get there!
 recording release: yes license: CC-BY-SA  

89. Empowering X.509 Certificate Management with Python
Marlon Dutra

Today, more than ever before, security is part of the fabric of the internet, with most websites defaulting to https over the historically used default of unsecured http. Whenever you see a URL starting with https:// (https:), your browser is sending the HTTP (or Spdy) traffic through a Transport Layer Security (TLS) tunnel. Part of establishing this secure tunnel involves your browser validating an X.509 certificate provided by the website you're viewing. This allows you to be sure that the server on the other end is who it says it is before you send some potentially sensitive information like your username and password.

This is just one example of how these technologies can be used, but there are many more. In distributed systems that communicate sensitive information, like user data, it is imperative to have a mutual authentication mechanism, where the client is confident it is talking to the right service, as well as the service being confident it is talking to the right client. Beyond strong authentication, it is usually desirable to have some authorization logic, to prevent clients from having unrestricted access to all services. 

Since any TCP communication can be tunneled through TLS, and TLS supports such mutual authentication through X.509 certificates, they are the perfect set of tools for the job. The problem to solve then becomes how you manage all of these certificates.

Crafting simple certificates with the openssl command line is a bit tricky but doable. However, modern certificates support a variety of advanced features and it is quite complicated to take full advantage of them through the command line, especially in a programmatic way. This is where Python can be a powerful tool. Through the use of certain libraries, you can inject valuable information into your certificates that can be used for many purposes, such as establishing a robust authorization model for a service.

In this session we'll explore some of the ways you can leverage X.509 certificate features to better protect your systems and data. We'll give specific examples of how to use Python for the programmatic management of complex certificates as well as talking about how the largest website on the Internet, Facebook, handles hundreds of thousands of such certificates in its internal infrastructure, using these same approaches.

By the end of this talk, you will understand how to craft your own elaborate certificates with Python and how to use them to secure communications between networked services.
 recording release: yes license: CC-BY-SA  

90. Releasing Calendar-Versioned Software
Amber Brown

Calendar-versioned software (or “calver”), in contrast to semantically versioned software (or “semver”), is released on regular intervals, rather than on the occurrence of features, bug fixes, or backwards compatibility breaking changes. This method of releasing software, notably used by Twisted and various related projects, eschews the “major.minor.patchlevel” format and the guarantees of a semver regime and instead focuses on providing robust backwards compatibility, clear deprecation cycles, and frequent but smaller releases. This talk discusses some of the trials and tribulations of the release process of such a project, Twisted, and the ways that it makes it work, as well as what tools are available to make the process easier if you wish to implement it yourself. 
 recording release: yes license: CC-BY-SA  

91. Functional Programming for Pythonistas
Bianca Gibson

Rampant side effects. 
The shifting sands of mutable state beneath your feet.
Enter Functional Programming.
Functional Programming helps you write more clear, maintainable and testable code.                   
This talk will cover the core principles of functional programming, how they relate to techniques you probably already use, how to apply them in python, the benefits they can offer and how to introduce them to other developers. 
 recording release: yes license: CC-BY-SA  

92. Teaching programming in undergraduate psychology
Damien Mannion

Psychology is a diverse discipline that involves the scientific study of behaviour and cognition. As part of undergraduate training in psychology, students are required to develop substantial skills in research methods and critical thinking. Here, I will discuss our recent efforts to use computer programming to aid in the student achievement of such outcomes. We have introduced a programming component in two third-year undergraduate psychology courses. As part of 'Vision & Brain', students learn to use Python (particularly the package 'PsychoPy') to implement their own vision science experiments. As part of 'Research Internship', students learn to use Python (particularly the 'numpy' and 'veusz' packages) to perform data analyses and to produce visualisations. The aim of these new course components is to provide students with a set of skills that will increase their ability to conduct research, but also to increase their problem solving and critical thinking skills through the process of coding. I will discuss our educational and practical implementation of such material and will use the results of student surveys and feedback to evaluate their effectiveness. Finally, I will discuss some of the challenges we encountered and give some indications of potential future developments.
 recording release: yes license: CC-BY-SA  

93. So you want to make a screencast?
Caleb Hattingh

Well, do you?  If so, there are a bunch of tips and tricks that you can learn that will get you up to speed very quickly.  

Creating lesson content is always demanding and time-consuming.  Using screencasts as a medium of instruction is no different, but there are clearly very specific habits that can make you much more efficient.  Specific advice about working with Python and the Jupyter Notebook will also be covered.

Secondly, this talk will also touch on aspects related to working with a publisher. These will include drafting the initial scope of work, negotiating timelines, and managing feedback and criticism.
 recording release: yes license: CC-BY-SA  

94. Learning TensorFlow
Robert Layton

The recently released TensorFlow library has caused great waves in machine learning circles, with its powerful syntax that allows for distributed computation, improved efficiency, and modularisation. The framework allows you to build graph-based models, such as those used in machine learning and artificial intelligence, and have those models run on a distributed computing systems, including GPUs.

This talk will cover what TensorFlow is, why/when you should use it, and cover the basics surrounding Variables, Placeholders, and Custom Functions. Importantly, there are several use cases *not* focused on data analytics - TensorFlow is more than just a machine learning library!
 recording release: yes license: CC-BY-SA  

95. The Evolution of Python Packaging at Facebook
Dan Reif

With tens of millions of Python invocations every day, what’s a packager to do?  The answer selected must account for the insanity of a deeply-heterogeneous production environment: different kernels, different OS distributions, even different versions of system Python.  It also needs enough context to carry with it a consistent reference point for when it was packaged relative to the work of thousands of engineers in a single, unified source control tree.  Lastly, at Facebook scale with hundreds of thousands of servers, every byte sent over the network and stored on disk counts, and every CPU cycle wasted can create a myriad of challenges associated with data center operations management.
 
Sure, it’d be easy to show what a beautiful, easy packaging format we’ve developed at Facebook, and sing its praises, but that’s not what this talk is about.  Instead, we’ll get into the nitty-gritty, and talk about hard tradeoffs that happen when developing a system in the real world.  This is an in-depth look at how Facebook’s packaging has evolved, warts and speed bumps included.  Some of the design goals we addressed (and/or issues we hit!) included:

* Synchronizing and pinning versioning of underlying compiled libraries across related tools
* Running the package as a transparently-Pythonic command-line utility, à la shebang, so we could do in-place replacements of packages written in other languages (e.g. C++)
* Optimizing package size transferred across the network
* Optimizing package sizes on disk
* Minimizing package launch times
* Handling packages launched from a network-FS location that subsequently goes offline

Attendees will learn about the different tools and techniques we used to solve these challenges, as well as the reasoning behind any trade offs that were made.
 recording release: yes license: CC-BY-SA  

96. Mental Health in Development
Eloise Macdonald-Meyer

This talk will explore the various mental health pressures and impacts that development can have, as well as the strategies developers, and their workplaces, can use to deal with them to support those who may be suffering.
Many conversations have been started about mental health in technology, and it is important for these to continue. Parts of the development process can sometimes lead to situations where looking after yourself can be difficult and it is important not only to be able to minimise the risk of these, but to be able to recognise them and find ways out of them. 
On the other hand, the amount of technology to help combat mental health is increasing, and what better demographic to test, use and further develop these technologies than developers themselves. This talk will also discuss the rise and continuity of technology to assist in mental health.
 recording release: yes license: CC-BY-SA  

97. Turning stories into websites
Donna Benjamin

The user story sits at the centre of most agile development methodologies. 

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

This talk puts the focus on the "user" telling the story to understand their requirements for the product. It then turns back to the team to look at how we hear and discuss those stories in order to bring them to life to build the product, and build it right.
 recording release: yes license: CC-BY-SA  

98. Predicting the TripleJ Hottest 100 With Python
Justin Warren

For several years now, I've used Python to help me attempt to predict the results of TripleJ's Hottest 100.

LEARN! how to write scripts that use more than CPU0 on your fancy multi-core laptop!

SEE! the alarming amount of information you can get through social network APIs.

MARVEL! at the myriad ways Optical Character Recognition will mangle your text!
 recording release: yes license: CC-BY-SA  

99. Preventing Cat-astrophes with GNU MediaGoblin
Ben Sturmfels

What would happen to all the cat videos if YouTube were to disappear? It would be a cat-atstrophe!

GNU MediaGoblin is Python-based media publishing system for artists — an alternative to centralised, censored and surveilled systems like Flickr, YouTube and SoundCloud. MediaGoblin gives people privacy, choice and control of their own media, something we need now more than ever.

This talk will explore the architecture of GNU MediaGoblin, the technical challenges in implementing fully decentralised sharing and commenting through PyPump and the Pump.io API as well as work to lower the Python deployment barrier to empower normal people to escape the centralised systems ("userops").
 recording release: yes license: CC-BY-SA  

100. Intentionally Blank


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

101. Hitting the Wall and How to Get Up Again - Tackling Burnout and Strategies for Self Care
Jackson Fairchild

It doesn't matter whether it is a labour of love, or you are working to pay the bills, or that delicious combination of both, there is a risk that one day you will hit the wall. Burnout is a looming menace in many communities, particularly those with long hours, tight deadlines, rigid dependencies, complex intellectual demands, uncertain rewards and moving goalposts. 

Why does it happen? How can we learn to understand ourselves well enough to spot the signs in ourselves and in other? How can we repair the damage and come back from the brink? Jackson Fairchild will present a lively, enlightening and funny talk based on his experience as both an experienced mental health clinician and a person who works too hard. 
 recording release: yes license: CC-BY-SA  

102. Intentionally Blank


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

103. Intentionally Blank


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

104. Intentionally Blank


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

105. Lightning Talks and Closing


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

106. Intentionally Blank


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

107. Intentionally Blank


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

108. Sprint


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

109. Sprint


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



Location
--------
Room 103


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